D:\ValheimDev\Dumps\Old\assembly_valheim\RandEventSystem.cs		D:\ValheimDev\Dumps\Latest\assembly_valheim\RandEventSystem.cs
	using System;		using System;
	using System.Collections.Generic;		using System.Collections.Generic;
	using System.IO;		using System.IO;
	using UnityEngine;		using UnityEngine;
	using UnityEngine.Rendering;		using UnityEngine.Rendering;
	public class RandEventSystem : MonoBehaviour		public class RandEventSystem : MonoBehaviour
	{		{
	public static RandEventSystem instance		public static RandEventSystem instance
	{		{
	get		get
	{		{
	return RandEventSystem.m_instance;		return RandEventSystem.m_instance;
	}		}
	}		}
	private void Awake()		private void Awake()
	{		{
	RandEventSystem.m_instance = this;		RandEventSystem.m_instance = this;
	}		}
	private void OnDestroy()		private void OnDestroy()
	{		{
	RandEventSystem.m_instance = null;		RandEventSystem.m_instance = null;
	}		}
	private void Start()		private void Start()
	{		{
	ZRoutedRpc.instance.Register<string, float, Vector3>("SetEvent", new Action<long, string, float, Vector3>(this.RPC_SetEvent));		ZRoutedRpc.instance.Register<string, float, Vector3>("SetEvent", new Action<long, string, float, Vector3>(this.RPC_SetEvent));
	}		}
	private void FixedUpdate()		private void FixedUpdate()
	{		{
	float fixedDeltaTime = Time.fixedDeltaTime;		float fixedDeltaTime = Time.fixedDeltaTime;
	this.UpdateForcedEvents(fixedDeltaTime);		this.UpdateForcedEvents(fixedDeltaTime);
	this.UpdateRandomEvent(fixedDeltaTime);		this.UpdateRandomEvent(fixedDeltaTime);
	if (this.m_forcedEvent != null)		if (this.m_forcedEvent != null)
	{		{
	this.m_forcedEvent.Update(ZNet.instance.IsServer(), this.m_forcedEvent == this.m_activeEvent, true, fixedDeltaTime);		this.m_forcedEvent.Update(ZNet.instance.IsServer(), this.m_forcedEvent == this.m_activeEvent, true, fixedDeltaTime);
	}		}
	if (this.m_randomEvent != null && ZNet.instance.IsServer())		if (this.m_randomEvent != null && ZNet.instance.IsServer())
	{		{
.	bool flag = this.IsAnyPlayerInEventArea(this.m_randomEvent);		if (ZNet.instance.IsServer())
	if (this.m_randomEvent.Update(true, this.m_randomEvent == this.m_activeEvent, flag, fixedDeltaTime))
	{		{
.	this.SetRandomEvent(null, Vector3.zero);		bool flag = this.IsAnyPlayerInEventArea(this.m_randomEvent);
			if (this.m_randomEvent.Update(true, this.m_randomEvent == this.m_activeEvent, flag, fixedDeltaTime))
			{
			this.SetRandomEvent(null, Vector3.zero);
			}
			}
			else
			{
			this.m_randomEvent.Update(ZNet.instance.IsServer(), this.m_randomEvent == this.m_activeEvent, true, fixedDeltaTime);
	}		}
	}		}
	if (this.m_forcedEvent != null)		if (this.m_forcedEvent != null)
	{		{
	this.SetActiveEvent(this.m_forcedEvent, false);		this.SetActiveEvent(this.m_forcedEvent, false);
	return;		return;
	}		}
	if (this.m_randomEvent == null || !Player.m_localPlayer)		if (this.m_randomEvent == null || !Player.m_localPlayer)
	{		{
	this.SetActiveEvent(null, false);		this.SetActiveEvent(null, false);
	return;		return;
	}		}
	if (this.IsInsideRandomEventArea(this.m_randomEvent, Player.m_localPlayer.transform.position))		if (this.IsInsideRandomEventArea(this.m_randomEvent, Player.m_localPlayer.transform.position))
	{		{
	this.SetActiveEvent(this.m_randomEvent, false);		this.SetActiveEvent(this.m_randomEvent, false);
	return;		return;
	}		}
	this.SetActiveEvent(null, false);		this.SetActiveEvent(null, false);
	}		}
	private bool IsInsideRandomEventArea(RandomEvent re, Vector3 position)		private bool IsInsideRandomEventArea(RandomEvent re, Vector3 position)
	{		{
.	return position.y <= 3000f && Utils.DistanceXZ(position, re.m_pos) < this.m_randomEventRange;		return position.y <= 3000f && Utils.DistanceXZ(position, re.m_pos) < re.m_eventRange;
	}		}
	private void UpdateRandomEvent(float dt)		private void UpdateRandomEvent(float dt)
	{		{
	if (ZNet.instance.IsServer())		if (ZNet.instance.IsServer())
	{		{
	this.m_eventTimer += dt;		this.m_eventTimer += dt;
	if (Game.m_eventRate > 0f && this.m_eventTimer > this.m_eventIntervalMin * 60f * Game.m_eventRate)		if (Game.m_eventRate > 0f && this.m_eventTimer > this.m_eventIntervalMin * 60f * Game.m_eventRate)
	{		{
	this.m_eventTimer = 0f;		this.m_eventTimer = 0f;
	if (UnityEngine.Random.Range(0f, 100f) <= this.m_eventChance / Game.m_eventRate)		if (UnityEngine.Random.Range(0f, 100f) <= this.m_eventChance / Game.m_eventRate)
	{		{
	this.StartRandomEvent();		this.StartRandomEvent();
	}		}
	}		}
.			if (RandEventSystem.s_randomEventNeedsRefresh)
			{
			RandEventSystem.RefreshPlayerEventData();
			}
			Player.GetAllPlayers();
			foreach (RandomEvent randomEvent in this.m_events)
			{
			if (randomEvent.m_enabled && randomEvent.m_standaloneInterval > 0f && this.m_activeEvent != randomEvent)
			{
			randomEvent.m_time += dt;
			if (randomEvent.m_time > randomEvent.m_standaloneInterval * Game.m_eventRate)
			{
			if (this.HaveGlobalKeys(randomEvent, RandEventSystem.s_playerEventDatas))
			{
			List<Vector3> validEventPoints = this.GetValidEventPoints(randomEvent, RandEventSystem.s_playerEventDatas);
			if (validEventPoints.Count > 0 && UnityEngine.Random.Range(0f, 100f) <= randomEvent.m_standaloneChance / Game.m_eventRate)
			{
			this.SetRandomEvent(randomEvent, validEventPoints[UnityEngine.Random.Range(0, validEventPoints.Count)]);
			}
			}
			randomEvent.m_time = 0f;
			}
			}
			}
	this.m_sendTimer += dt;		this.m_sendTimer += dt;
	if (this.m_sendTimer > 2f)		if (this.m_sendTimer > 2f)
	{		{
	this.m_sendTimer = 0f;		this.m_sendTimer = 0f;
	this.SendCurrentRandomEvent();		this.SendCurrentRandomEvent();
	}		}
	}		}
	}		}
	private void UpdateForcedEvents(float dt)		private void UpdateForcedEvents(float dt)
	{		{
	this.m_forcedEventUpdateTimer += dt;		this.m_forcedEventUpdateTimer += dt;
	if (this.m_forcedEventUpdateTimer > 2f)		if (this.m_forcedEventUpdateTimer > 2f)
	{		{
	this.m_forcedEventUpdateTimer = 0f;		this.m_forcedEventUpdateTimer = 0f;
	string forcedEvent = this.GetForcedEvent();		string forcedEvent = this.GetForcedEvent();
	this.SetForcedEvent(forcedEvent);		this.SetForcedEvent(forcedEvent);
	}		}
	}		}
	private void SetForcedEvent(string name)		private void SetForcedEvent(string name)
	{		{
	if (this.m_forcedEvent != null && name != null && this.m_forcedEvent.m_name == name)		if (this.m_forcedEvent != null && name != null && this.m_forcedEvent.m_name == name)
	{		{
	return;		return;
	}		}
	if (this.m_forcedEvent != null)		if (this.m_forcedEvent != null)
	{		{
	if (this.m_forcedEvent == this.m_activeEvent)		if (this.m_forcedEvent == this.m_activeEvent)
	{		{
	this.SetActiveEvent(null, true);		this.SetActiveEvent(null, true);
	}		}
	this.m_forcedEvent.OnStop();		this.m_forcedEvent.OnStop();
	this.m_forcedEvent = null;		this.m_forcedEvent = null;
	}		}
	RandomEvent @event = this.GetEvent(name);		RandomEvent @event = this.GetEvent(name);
	if (@event != null)		if (@event != null)
	{		{
	this.m_forcedEvent = @event.Clone();		this.m_forcedEvent = @event.Clone();
	this.m_forcedEvent.OnStart();		this.m_forcedEvent.OnStart();
	}		}
	}		}
	private string GetForcedEvent()		private string GetForcedEvent()
	{		{
	if (EnemyHud.instance != null)		if (EnemyHud.instance != null)
	{		{
	Character activeBoss = EnemyHud.instance.GetActiveBoss();		Character activeBoss = EnemyHud.instance.GetActiveBoss();
	if (activeBoss != null && activeBoss.m_bossEvent.Length > 0)		if (activeBoss != null && activeBoss.m_bossEvent.Length > 0)
	{		{
	return activeBoss.m_bossEvent;		return activeBoss.m_bossEvent;
	}		}
	string @event = EventZone.GetEvent();		string @event = EventZone.GetEvent();
	if (@event != null)		if (@event != null)
	{		{
	return @event;		return @event;
	}		}
	}		}
	return null;		return null;
	}		}
	public string GetBossEvent()		public string GetBossEvent()
	{		{
	if (EnemyHud.instance != null)		if (EnemyHud.instance != null)
	{		{
	Character activeBoss = EnemyHud.instance.GetActiveBoss();		Character activeBoss = EnemyHud.instance.GetActiveBoss();
	if (activeBoss != null && activeBoss.m_bossEvent.Length > 0)		if (activeBoss != null && activeBoss.m_bossEvent.Length > 0)
	{		{
	return activeBoss.m_bossEvent;		return activeBoss.m_bossEvent;
	}		}
	}		}
	return null;		return null;
	}		}
	private void SendCurrentRandomEvent()		private void SendCurrentRandomEvent()
	{		{
	if (this.m_randomEvent != null)		if (this.m_randomEvent != null)
	{		{
	ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "SetEvent", new object[]		ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "SetEvent", new object[]
	{		{
	this.m_randomEvent.m_name,		this.m_randomEvent.m_name,
	this.m_randomEvent.m_time,		this.m_randomEvent.m_time,
	this.m_randomEvent.m_pos		this.m_randomEvent.m_pos
	});		});
	return;		return;
	}		}
	ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "SetEvent", new object[]		ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "SetEvent", new object[]
	{		{
	"",		"",
	0f,		0f,
	Vector3.zero		Vector3.zero
	});		});
	}		}
	private void RPC_SetEvent(long sender, string eventName, float time, Vector3 pos)		private void RPC_SetEvent(long sender, string eventName, float time, Vector3 pos)
	{		{
	if (ZNet.instance.IsServer())		if (ZNet.instance.IsServer())
	{		{
	return;		return;
	}		}
	if (this.m_randomEvent == null || this.m_randomEvent.m_name != eventName)		if (this.m_randomEvent == null || this.m_randomEvent.m_name != eventName)
	{		{
	this.SetRandomEventByName(eventName, pos);		this.SetRandomEventByName(eventName, pos);
	}		}
	if (this.m_randomEvent != null)		if (this.m_randomEvent != null)
	{		{
	this.m_randomEvent.m_time = time;		this.m_randomEvent.m_time = time;
	this.m_randomEvent.m_pos = pos;		this.m_randomEvent.m_pos = pos;
	}		}
	}		}
	public void ConsoleStartRandomEvent()		public void ConsoleStartRandomEvent()
	{		{
	if (ZNet.instance.IsServer())		if (ZNet.instance.IsServer())
	{		{
	this.StartRandomEvent();		this.StartRandomEvent();
	return;		return;
	}		}
	ZRoutedRpc.instance.InvokeRoutedRPC("startrandomevent", Array.Empty<object>());		ZRoutedRpc.instance.InvokeRoutedRPC("startrandomevent", Array.Empty<object>());
	}		}
	private void RPC_ConsoleStartRandomEvent(long sender)		private void RPC_ConsoleStartRandomEvent(long sender)
	{		{
	ZNetPeer peer = ZNet.instance.GetPeer(sender);		ZNetPeer peer = ZNet.instance.GetPeer(sender);
	if (!ZNet.instance.IsAdmin(peer.m_socket.GetHostName()))		if (!ZNet.instance.IsAdmin(peer.m_socket.GetHostName()))
	{		{
	ZNet.instance.RemotePrint(peer.m_rpc, "You are not admin");		ZNet.instance.RemotePrint(peer.m_rpc, "You are not admin");
	return;		return;
	}		}
	this.StartRandomEvent();		this.StartRandomEvent();
	}		}
	public void ConsoleResetRandomEvent()		public void ConsoleResetRandomEvent()
	{		{
	if (ZNet.instance.IsServer())		if (ZNet.instance.IsServer())
	{		{
	this.ResetRandomEvent();		this.ResetRandomEvent();
	return;		return;
	}		}
	ZRoutedRpc.instance.InvokeRoutedRPC("resetrandomevent", Array.Empty<object>());		ZRoutedRpc.instance.InvokeRoutedRPC("resetrandomevent", Array.Empty<object>());
	}		}
	private void RPC_ConsoleResetRandomEvent(long sender)		private void RPC_ConsoleResetRandomEvent(long sender)
	{		{
	ZNetPeer peer = ZNet.instance.GetPeer(sender);		ZNetPeer peer = ZNet.instance.GetPeer(sender);
	if (!ZNet.instance.IsAdmin(peer.m_socket.GetHostName()))		if (!ZNet.instance.IsAdmin(peer.m_socket.GetHostName()))
	{		{
	ZNet.instance.RemotePrint(peer.m_rpc, "You are not admin");		ZNet.instance.RemotePrint(peer.m_rpc, "You are not admin");
	return;		return;
	}		}
	this.ResetRandomEvent();		this.ResetRandomEvent();
	}		}
	public void StartRandomEvent()		public void StartRandomEvent()
	{		{
	if (!ZNet.instance.IsServer())		if (!ZNet.instance.IsServer())
	{		{
	return;		return;
	}		}
	List<KeyValuePair<RandomEvent, Vector3>> possibleRandomEvents = this.GetPossibleRandomEvents();		List<KeyValuePair<RandomEvent, Vector3>> possibleRandomEvents = this.GetPossibleRandomEvents();
.	Terminal.Log("Possible events:" + possibleRandomEvents.Count.ToString());		Terminal.Log(string.Format("Possible events: {0}", possibleRandomEvents.Count));
	if (possibleRandomEvents.Count == 0)		if (possibleRandomEvents.Count == 0)
	{		{
	return;		return;
	}		}
	foreach (KeyValuePair<RandomEvent, Vector3> keyValuePair in possibleRandomEvents)		foreach (KeyValuePair<RandomEvent, Vector3> keyValuePair in possibleRandomEvents)
	{		{
	Terminal.Log("  " + keyValuePair.Key.m_name);		Terminal.Log("  " + keyValuePair.Key.m_name);
	}		}
	KeyValuePair<RandomEvent, Vector3> keyValuePair2 = possibleRandomEvents[UnityEngine.Random.Range(0, possibleRandomEvents.Count)];		KeyValuePair<RandomEvent, Vector3> keyValuePair2 = possibleRandomEvents[UnityEngine.Random.Range(0, possibleRandomEvents.Count)];
	this.SetRandomEvent(keyValuePair2.Key, keyValuePair2.Value);		this.SetRandomEvent(keyValuePair2.Key, keyValuePair2.Value);
	Terminal.Log("Starting event: " + keyValuePair2.Key.m_name);		Terminal.Log("Starting event: " + keyValuePair2.Key.m_name);
	}		}
	private RandomEvent GetEvent(string name)		private RandomEvent GetEvent(string name)
	{		{
	if (string.IsNullOrEmpty(name))		if (string.IsNullOrEmpty(name))
	{		{
	return null;		return null;
	}		}
	foreach (RandomEvent randomEvent in this.m_events)		foreach (RandomEvent randomEvent in this.m_events)
	{		{
	if (randomEvent.m_name == name && randomEvent.m_enabled)		if (randomEvent.m_name == name && randomEvent.m_enabled)
	{		{
	return randomEvent;		return randomEvent;
	}		}
	}		}
	return null;		return null;
	}		}
	public void SetRandomEventByName(string name, Vector3 pos)		public void SetRandomEventByName(string name, Vector3 pos)
	{		{
	RandomEvent @event = this.GetEvent(name);		RandomEvent @event = this.GetEvent(name);
	this.SetRandomEvent(@event, pos);		this.SetRandomEvent(@event, pos);
	}		}
	public void ResetRandomEvent()		public void ResetRandomEvent()
	{		{
	this.SetRandomEvent(null, Vector3.zero);		this.SetRandomEvent(null, Vector3.zero);
	}		}
	public bool HaveEvent(string name)		public bool HaveEvent(string name)
	{		{
	return this.GetEvent(name) != null;		return this.GetEvent(name) != null;
	}		}
	private void SetRandomEvent(RandomEvent ev, Vector3 pos)		private void SetRandomEvent(RandomEvent ev, Vector3 pos)
	{		{
	if (this.m_randomEvent != null)		if (this.m_randomEvent != null)
	{		{
	if (this.m_randomEvent == this.m_activeEvent)		if (this.m_randomEvent == this.m_activeEvent)
	{		{
	this.SetActiveEvent(null, true);		this.SetActiveEvent(null, true);
	}		}
	this.m_randomEvent.OnStop();		this.m_randomEvent.OnStop();
	this.m_randomEvent = null;		this.m_randomEvent = null;
	}		}
	if (ev != null)		if (ev != null)
	{		{
	this.m_randomEvent = ev.Clone();		this.m_randomEvent = ev.Clone();
	this.m_randomEvent.m_pos = pos;		this.m_randomEvent.m_pos = pos;
	this.m_randomEvent.OnStart();		this.m_randomEvent.OnStart();
	ZLog.Log("Random event set:" + ev.m_name);		ZLog.Log("Random event set:" + ev.m_name);
	if (Player.m_localPlayer)		if (Player.m_localPlayer)
	{		{
	Player.m_localPlayer.ShowTutorial("randomevent", false);		Player.m_localPlayer.ShowTutorial("randomevent", false);
	}		}
	}		}
	if (ZNet.instance.IsServer())		if (ZNet.instance.IsServer())
	{		{
	this.SendCurrentRandomEvent();		this.SendCurrentRandomEvent();
	}		}
	}		}
	private bool IsAnyPlayerInEventArea(RandomEvent re)		private bool IsAnyPlayerInEventArea(RandomEvent re)
	{		{
	foreach (ZDO zdo in ZNet.instance.GetAllCharacterZDOS())		foreach (ZDO zdo in ZNet.instance.GetAllCharacterZDOS())
	{		{
	if (this.IsInsideRandomEventArea(re, zdo.GetPosition()))		if (this.IsInsideRandomEventArea(re, zdo.GetPosition()))
	{		{
	return true;		return true;
	}		}
	}		}
	return false;		return false;
	}		}
	private List<KeyValuePair<RandomEvent, Vector3>> GetPossibleRandomEvents()		private List<KeyValuePair<RandomEvent, Vector3>> GetPossibleRandomEvents()
	{		{
	this.m_lastPossibleEvents.Clear();		this.m_lastPossibleEvents.Clear();
	RandEventSystem.RefreshPlayerEventData();		RandEventSystem.RefreshPlayerEventData();
	foreach (RandomEvent randomEvent in this.m_events)		foreach (RandomEvent randomEvent in this.m_events)
	{		{
.	if (randomEvent.m_enabled && randomEvent.m_random && this.HaveGlobalKeys(randomEvent, RandEventSystem.playerEventDatas))		if (randomEvent.m_enabled && randomEvent.m_random && this.HaveGlobalKeys(randomEvent, RandEventSystem.s_playerEventDatas))
	{		{
.	List<Vector3> validEventPoints = this.GetValidEventPoints(randomEvent, RandEventSystem.playerEventDatas);		List<Vector3> validEventPoints = this.GetValidEventPoints(randomEvent, RandEventSystem.s_playerEventDatas);
	if (validEventPoints.Count != 0)		if (validEventPoints.Count != 0)
	{		{
	Vector3 vector = validEventPoints[UnityEngine.Random.Range(0, validEventPoints.Count)];		Vector3 vector = validEventPoints[UnityEngine.Random.Range(0, validEventPoints.Count)];
	this.m_lastPossibleEvents.Add(new KeyValuePair<RandomEvent, Vector3>(randomEvent, vector));		this.m_lastPossibleEvents.Add(new KeyValuePair<RandomEvent, Vector3>(randomEvent, vector));
	}		}
	}		}
	}		}
	return this.m_lastPossibleEvents;		return this.m_lastPossibleEvents;
	}		}
	private List<Vector3> GetValidEventPoints(RandomEvent ev, List<RandEventSystem.PlayerEventData> characters)		private List<Vector3> GetValidEventPoints(RandomEvent ev, List<RandEventSystem.PlayerEventData> characters)
	{		{
	this.points.Clear();		this.points.Clear();
	bool globalKey = ZoneSystem.instance.GetGlobalKey(GlobalKeys.PlayerEvents);		bool globalKey = ZoneSystem.instance.GetGlobalKey(GlobalKeys.PlayerEvents);
	foreach (RandEventSystem.PlayerEventData playerEventData in characters)		foreach (RandEventSystem.PlayerEventData playerEventData in characters)
	{		{
	if (this.InValidBiome(ev, playerEventData.position) && this.CheckBase(ev, playerEventData) && playerEventData.position.y <= 3000f && (!globalKey || playerEventData.possibleEvents.Contains(ev.m_name)))		if (this.InValidBiome(ev, playerEventData.position) && this.CheckBase(ev, playerEventData) && playerEventData.position.y <= 3000f && (!globalKey || playerEventData.possibleEvents.Contains(ev.m_name)))
	{		{
	this.points.Add(playerEventData.position);		this.points.Add(playerEventData.position);
	}		}
	}		}
	return this.points;		return this.points;
	}		}
.	public static List<RandEventSystem.PlayerEventData> RefreshPlayerEventData()		private static void RefreshPlayerEventData()
	{		{
.	RandEventSystem.playerEventDatas.Clear();		RandEventSystem.s_randomEventNeedsRefresh = false;
			RandEventSystem.s_playerEventDatas.Clear();
	RandEventSystem.PlayerEventData playerEventData;		RandEventSystem.PlayerEventData playerEventData;
	if (SystemInfo.graphicsDeviceType != GraphicsDeviceType.Null && RandEventSystem.RetrievePlayerEventData(ZNet.instance.m_serverSyncedPlayerData, ZNet.instance.GetReferencePosition(), out playerEventData))		if (SystemInfo.graphicsDeviceType != GraphicsDeviceType.Null && RandEventSystem.RetrievePlayerEventData(ZNet.instance.m_serverSyncedPlayerData, ZNet.instance.GetReferencePosition(), out playerEventData))
	{		{
.	RandEventSystem.playerEventDatas.Add(playerEventData);		RandEventSystem.s_playerEventDatas.Add(playerEventData);
	}		}
	foreach (ZNetPeer znetPeer in ZNet.instance.GetPeers())		foreach (ZNetPeer znetPeer in ZNet.instance.GetPeers())
	{		{
	RandEventSystem.PlayerEventData playerEventData2;		RandEventSystem.PlayerEventData playerEventData2;
	if (znetPeer.IsReady() && RandEventSystem.RetrievePlayerEventData(znetPeer.m_serverSyncedPlayerData, znetPeer.m_refPos, out playerEventData2))		if (znetPeer.IsReady() && RandEventSystem.RetrievePlayerEventData(znetPeer.m_serverSyncedPlayerData, znetPeer.m_refPos, out playerEventData2))
	{		{
.	RandEventSystem.playerEventDatas.Add(playerEventData2);		RandEventSystem.s_playerEventDatas.Add(playerEventData2);
	}		}
	}		}
.	return RandEventSystem.playerEventDatas;		}
			public static void SetRandomEventsNeedsRefresh()
			{
			RandEventSystem.s_randomEventNeedsRefresh = true;
	}		}
	private static bool RetrievePlayerEventData(Dictionary<string, string> playerData, Vector3 position, out RandEventSystem.PlayerEventData eventData)		private static bool RetrievePlayerEventData(Dictionary<string, string> playerData, Vector3 position, out RandEventSystem.PlayerEventData eventData)
	{		{
	eventData = default(RandEventSystem.PlayerEventData);		eventData = default(RandEventSystem.PlayerEventData);
	string text;		string text;
	if (!playerData.TryGetValue("possibleEvents", out text))		if (!playerData.TryGetValue("possibleEvents", out text))
	{		{
	return false;		return false;
	}		}
	string text2;		string text2;
	if (!playerData.TryGetValue("baseValue", out text2) || !int.TryParse(text2, out eventData.baseValue))		if (!playerData.TryGetValue("baseValue", out text2) || !int.TryParse(text2, out eventData.baseValue))
	{		{
	return false;		return false;
	}		}
	eventData.position = position;		eventData.position = position;
	eventData.possibleEvents = new HashSet<string>();		eventData.possibleEvents = new HashSet<string>();
	string[] array = text.Split(',', StringSplitOptions.None);		string[] array = text.Split(',', StringSplitOptions.None);
	for (int i = 0; i < array.Length; i++)		for (int i = 0; i < array.Length; i++)
	{		{
	eventData.possibleEvents.Add(array[i]);		eventData.possibleEvents.Add(array[i]);
	}		}
	return true;		return true;
	}		}
	private bool InValidBiome(RandomEvent ev, Vector3 point)		private bool InValidBiome(RandomEvent ev, Vector3 point)
	{		{
	return ev.m_biome == Heightmap.Biome.None || (WorldGenerator.instance.GetBiome(point) & ev.m_biome) != Heightmap.Biome.None;		return ev.m_biome == Heightmap.Biome.None || (WorldGenerator.instance.GetBiome(point) & ev.m_biome) != Heightmap.Biome.None;
	}		}
	private bool CheckBase(RandomEvent ev, RandEventSystem.PlayerEventData player)		private bool CheckBase(RandomEvent ev, RandEventSystem.PlayerEventData player)
	{		{
	return !ev.m_nearBaseOnly || player.baseValue >= 3;		return !ev.m_nearBaseOnly || player.baseValue >= 3;
	}		}
	private bool HaveGlobalKeys(RandomEvent ev, List<RandEventSystem.PlayerEventData> players)		private bool HaveGlobalKeys(RandomEvent ev, List<RandEventSystem.PlayerEventData> players)
	{		{
	if (ZoneSystem.instance.GetGlobalKey(GlobalKeys.PlayerEvents) && (ev.m_altRequiredKnownItems.Count > 0 || ev.m_altRequiredNotKnownItems.Count > 0 || ev.m_altNotRequiredPlayerKeys.Count > 0 || ev.m_altRequiredPlayerKeysAny.Count > 0))		if (ZoneSystem.instance.GetGlobalKey(GlobalKeys.PlayerEvents) && (ev.m_altRequiredKnownItems.Count > 0 || ev.m_altRequiredNotKnownItems.Count > 0 || ev.m_altNotRequiredPlayerKeys.Count > 0 || ev.m_altRequiredPlayerKeysAny.Count > 0))
	{		{
	using (List<RandEventSystem.PlayerEventData>.Enumerator enumerator = players.GetEnumerator())		using (List<RandEventSystem.PlayerEventData>.Enumerator enumerator = players.GetEnumerator())
	{		{
	while (enumerator.MoveNext())		while (enumerator.MoveNext())
	{		{
	if (enumerator.Current.possibleEvents.Contains(ev.m_name))		if (enumerator.Current.possibleEvents.Contains(ev.m_name))
	{		{
	return true;		return true;
	}		}
	}		}
	}		}
	return false;		return false;
	}		}
	foreach (string text in ev.m_requiredGlobalKeys)		foreach (string text in ev.m_requiredGlobalKeys)
	{		{
	if (!ZoneSystem.instance.GetGlobalKey(text))		if (!ZoneSystem.instance.GetGlobalKey(text))
	{		{
	return false;		return false;
	}		}
	}		}
	foreach (string text2 in ev.m_notRequiredGlobalKeys)		foreach (string text2 in ev.m_notRequiredGlobalKeys)
	{		{
	if (ZoneSystem.instance.GetGlobalKey(text2))		if (ZoneSystem.instance.GetGlobalKey(text2))
	{		{
	return false;		return false;
	}		}
	}		}
	return true;		return true;
	}		}
	public bool PlayerIsReadyForEvent(Player player, RandomEvent ev)		public bool PlayerIsReadyForEvent(Player player, RandomEvent ev)
	{		{
	foreach (ItemDrop itemDrop in ev.m_altRequiredNotKnownItems)		foreach (ItemDrop itemDrop in ev.m_altRequiredNotKnownItems)
	{		{
	if (player.IsMaterialKnown(itemDrop.m_itemData.m_shared.m_name))		if (player.IsMaterialKnown(itemDrop.m_itemData.m_shared.m_name))
	{		{
	return false;		return false;
	}		}
	}		}
	foreach (string text in ev.m_altNotRequiredPlayerKeys)		foreach (string text in ev.m_altNotRequiredPlayerKeys)
	{		{
	if (player.HaveUniqueKey(text))		if (player.HaveUniqueKey(text))
	{		{
	return false;		return false;
	}		}
	}		}
	foreach (ItemDrop itemDrop2 in ev.m_altRequiredKnownItems)		foreach (ItemDrop itemDrop2 in ev.m_altRequiredKnownItems)
	{		{
	if (player.IsMaterialKnown(itemDrop2.m_itemData.m_shared.m_name))		if (player.IsMaterialKnown(itemDrop2.m_itemData.m_shared.m_name))
	{		{
	return true;		return true;
	}		}
	}		}
	foreach (string text2 in ev.m_altRequiredPlayerKeysAny)		foreach (string text2 in ev.m_altRequiredPlayerKeysAny)
	{		{
	if (player.HaveUniqueKey(text2))		if (player.HaveUniqueKey(text2))
	{		{
	return true;		return true;
	}		}
	}		}
	return ev.m_altRequiredKnownItems.Count <= 0 && ev.m_altRequiredPlayerKeysAny.Count <= 0;		return ev.m_altRequiredKnownItems.Count <= 0 && ev.m_altRequiredPlayerKeysAny.Count <= 0;
	}		}
	public List<SpawnSystem.SpawnData> GetCurrentSpawners()		public List<SpawnSystem.SpawnData> GetCurrentSpawners()
	{		{
.	if (this.m_activeEvent != null)		if (this.m_activeEvent != null && this.m_activeEvent.m_time > this.m_activeEvent.m_spawnerDelay)
	{		{
	return this.m_activeEvent.m_spawn;		return this.m_activeEvent.m_spawn;
	}		}
	return null;		return null;
	}		}
	public string GetEnvOverride()		public string GetEnvOverride()
	{		{
	if (this.m_activeEvent != null && !string.IsNullOrEmpty(this.m_activeEvent.m_forceEnvironment) && this.m_activeEvent.InEventBiome())		if (this.m_activeEvent != null && !string.IsNullOrEmpty(this.m_activeEvent.m_forceEnvironment) && this.m_activeEvent.InEventBiome())
	{		{
	return this.m_activeEvent.m_forceEnvironment;		return this.m_activeEvent.m_forceEnvironment;
	}		}
	return null;		return null;
	}		}
	public string GetMusicOverride()		public string GetMusicOverride()
	{		{
	if (this.m_activeEvent != null && !string.IsNullOrEmpty(this.m_activeEvent.m_forceMusic))		if (this.m_activeEvent != null && !string.IsNullOrEmpty(this.m_activeEvent.m_forceMusic))
	{		{
	return this.m_activeEvent.m_forceMusic;		return this.m_activeEvent.m_forceMusic;
	}		}
	return null;		return null;
	}		}
	private void SetActiveEvent(RandomEvent ev, bool end = false)		private void SetActiveEvent(RandomEvent ev, bool end = false)
	{		{
	if (ev != null && this.m_activeEvent != null && ev.m_name == this.m_activeEvent.m_name)		if (ev != null && this.m_activeEvent != null && ev.m_name == this.m_activeEvent.m_name)
	{		{
	return;		return;
	}		}
	if (this.m_activeEvent != null)		if (this.m_activeEvent != null)
	{		{
	this.m_activeEvent.OnDeactivate(end);		this.m_activeEvent.OnDeactivate(end);
	this.m_activeEvent = null;		this.m_activeEvent = null;
	}		}
	if (ev != null)		if (ev != null)
	{		{
	this.m_activeEvent = ev;		this.m_activeEvent = ev;
	if (this.m_activeEvent != null)		if (this.m_activeEvent != null)
	{		{
	this.m_activeEvent.OnActivate();		this.m_activeEvent.OnActivate();
	}		}
	}		}
	}		}
	public static bool InEvent()		public static bool InEvent()
	{		{
	return !(RandEventSystem.m_instance == null) && RandEventSystem.m_instance.m_activeEvent != null;		return !(RandEventSystem.m_instance == null) && RandEventSystem.m_instance.m_activeEvent != null;
	}		}
	public static bool HaveActiveEvent()		public static bool HaveActiveEvent()
	{		{
	return !(RandEventSystem.m_instance == null) && (RandEventSystem.m_instance.m_activeEvent != null || RandEventSystem.m_instance.m_randomEvent != null || RandEventSystem.m_instance.m_activeEvent != null);		return !(RandEventSystem.m_instance == null) && (RandEventSystem.m_instance.m_activeEvent != null || RandEventSystem.m_instance.m_randomEvent != null || RandEventSystem.m_instance.m_activeEvent != null);
	}		}
	public RandomEvent GetCurrentRandomEvent()		public RandomEvent GetCurrentRandomEvent()
	{		{
	return this.m_randomEvent;		return this.m_randomEvent;
	}		}
	public RandomEvent GetActiveEvent()		public RandomEvent GetActiveEvent()
	{		{
	return this.m_activeEvent;		return this.m_activeEvent;
	}		}
	public void PrepareSave()		public void PrepareSave()
	{		{
	this.m_tempSaveEventTimer = this.m_eventTimer;		this.m_tempSaveEventTimer = this.m_eventTimer;
	if (this.m_randomEvent != null)		if (this.m_randomEvent != null)
	{		{
	this.m_tempSaveRandomEvent = this.m_randomEvent.m_name;		this.m_tempSaveRandomEvent = this.m_randomEvent.m_name;
	this.m_tempSaveRandomEventTime = this.m_randomEvent.m_time;		this.m_tempSaveRandomEventTime = this.m_randomEvent.m_time;
	this.m_tempSaveRandomEventPos = this.m_randomEvent.m_pos;		this.m_tempSaveRandomEventPos = this.m_randomEvent.m_pos;
	return;		return;
	}		}
	this.m_tempSaveRandomEvent = "";		this.m_tempSaveRandomEvent = "";
	this.m_tempSaveRandomEventTime = 0f;		this.m_tempSaveRandomEventTime = 0f;
	this.m_tempSaveRandomEventPos = Vector3.zero;		this.m_tempSaveRandomEventPos = Vector3.zero;
	}		}
	public void SaveAsync(BinaryWriter writer)		public void SaveAsync(BinaryWriter writer)
	{		{
	writer.Write(this.m_tempSaveEventTimer);		writer.Write(this.m_tempSaveEventTimer);
	writer.Write(this.m_tempSaveRandomEvent);		writer.Write(this.m_tempSaveRandomEvent);
	writer.Write(this.m_tempSaveRandomEventTime);		writer.Write(this.m_tempSaveRandomEventTime);
	writer.Write(this.m_tempSaveRandomEventPos.x);		writer.Write(this.m_tempSaveRandomEventPos.x);
	writer.Write(this.m_tempSaveRandomEventPos.y);		writer.Write(this.m_tempSaveRandomEventPos.y);
	writer.Write(this.m_tempSaveRandomEventPos.z);		writer.Write(this.m_tempSaveRandomEventPos.z);
	}		}
	public void Load(BinaryReader reader, int version)		public void Load(BinaryReader reader, int version)
	{		{
	this.m_eventTimer = reader.ReadSingle();		this.m_eventTimer = reader.ReadSingle();
	if (version >= 25)		if (version >= 25)
	{		{
	string text = reader.ReadString();		string text = reader.ReadString();
	float num = reader.ReadSingle();		float num = reader.ReadSingle();
	Vector3 vector;		Vector3 vector;
	vector.x = reader.ReadSingle();		vector.x = reader.ReadSingle();
	vector.y = reader.ReadSingle();		vector.y = reader.ReadSingle();
	vector.z = reader.ReadSingle();		vector.z = reader.ReadSingle();
	if (!string.IsNullOrEmpty(text))		if (!string.IsNullOrEmpty(text))
	{		{
	this.SetRandomEventByName(text, vector);		this.SetRandomEventByName(text, vector);
	if (this.m_randomEvent != null)		if (this.m_randomEvent != null)
	{		{
	this.m_randomEvent.m_time = num;		this.m_randomEvent.m_time = num;
	this.m_randomEvent.m_pos = vector;		this.m_randomEvent.m_pos = vector;
	}		}
	}		}
	}		}
	}		}
	private List<Vector3> points = new List<Vector3>();		private List<Vector3> points = new List<Vector3>();
	private static RandEventSystem m_instance;		private static RandEventSystem m_instance;
	private List<KeyValuePair<RandomEvent, Vector3>> m_lastPossibleEvents = new List<KeyValuePair<RandomEvent, Vector3>>();		private List<KeyValuePair<RandomEvent, Vector3>> m_lastPossibleEvents = new List<KeyValuePair<RandomEvent, Vector3>>();
.	private static List<RandEventSystem.PlayerEventData> playerEventDatas = new List<RandEventSystem.PlayerEventData>();		private static List<RandEventSystem.PlayerEventData> s_playerEventDatas = new List<RandEventSystem.PlayerEventData>();
			private static bool s_randomEventNeedsRefresh = true;
	public float m_eventIntervalMin = 1f;		public float m_eventIntervalMin = 1f;
	public float m_eventChance = 25f;		public float m_eventChance = 25f;
.
	public float m_randomEventRange = 200f;
	private float m_eventTimer;		private float m_eventTimer;
	private float m_sendTimer;		private float m_sendTimer;
	public List<RandomEvent> m_events = new List<RandomEvent>();		public List<RandomEvent> m_events = new List<RandomEvent>();
	private RandomEvent m_randomEvent;		private RandomEvent m_randomEvent;
	private float m_forcedEventUpdateTimer;		private float m_forcedEventUpdateTimer;
	private RandomEvent m_forcedEvent;		private RandomEvent m_forcedEvent;
	private RandomEvent m_activeEvent;		private RandomEvent m_activeEvent;
	private float m_tempSaveEventTimer;		private float m_tempSaveEventTimer;
	private string m_tempSaveRandomEvent;		private string m_tempSaveRandomEvent;
	private float m_tempSaveRandomEventTime;		private float m_tempSaveRandomEventTime;
	private Vector3 m_tempSaveRandomEventPos;		private Vector3 m_tempSaveRandomEventPos;
	public const string PossibleEventsKey = "possibleEvents";		public const string PossibleEventsKey = "possibleEvents";
	public struct PlayerEventData		public struct PlayerEventData
	{		{
	public Vector3 position;		public Vector3 position;
	public HashSet<string> possibleEvents;		public HashSet<string> possibleEvents;
	public int baseValue;		public int baseValue;
	}		}
	}		}