using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
using Zorro.Core;
using pworld.Scripts.Extensions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("dedicatedserverinator")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: AssemblyProduct("dedicatedserverinator")]
[assembly: AssemblyTitle("dedicatedserverinator")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace dsi
{
	[HarmonyPatch(typeof(EndScreen), "EndSequenceRoutine")]
	internal static class DoTheStuff
	{
		public static float deathWait;

		private static void Prefix(EndScreen __instance)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				ExtGameObject.GetOrAddComponent<DeathHandler>(((Component)Character.localCharacter).gameObject).fella = Character.localCharacter;
			}
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "Update")]
	internal static class DoTheStuffAtTheAirport
	{
		public static IntermissionHandler intHandler;

		private static void Postfix(CharacterAfflictions __instance)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.IsMasterClient)
			{
				return;
			}
			if (Input.GetKeyDown(Plugin.enableAllKeybind.Value))
			{
				PlayerConnectionLog val = Object.FindAnyObjectByType<PlayerConnectionLog>();
				if (Plugin.enabled.Value && Plugin.KYSEnabled.Value && Plugin.LPMEnabled.Value)
				{
					Plugin.enabled.Value = false;
					Plugin.KYSEnabled.Value = false;
					Plugin.LPMEnabled.Value = false;
					string text = "<color=#" + ColorUtility.ToHtmlStringRGB(Color.red) + ">Everything is disabled.";
					val.AddMessage(text);
					val.sfxLeave.Play(default(Vector3));
				}
				else
				{
					Plugin.enabled.Value = true;
					Plugin.KYSEnabled.Value = true;
					Plugin.LPMEnabled.Value = true;
					string text2 = "<color=#" + ColorUtility.ToHtmlStringRGB(Color.green) + ">Everything is enabled.";
					val.AddMessage(text2);
					val.sfxJoin.Play(default(Vector3));
				}
			}
			if (Input.GetKeyDown(Plugin.enableKYSKeybind.Value))
			{
				Plugin.KYSEnabled.Value = !Plugin.KYSEnabled.Value;
				PlayerConnectionLog val2 = Object.FindAnyObjectByType<PlayerConnectionLog>();
				if ((Object)(object)val2 != (Object)null)
				{
					if (Plugin.KYSEnabled.Value)
					{
						string text3 = "<color=#" + ColorUtility.ToHtmlStringRGB(Color.green) + ">Auto kill is enabled";
						val2.AddMessage(text3);
						val2.sfxJoin.Play(default(Vector3));
					}
					else
					{
						string text4 = "<color=#" + ColorUtility.ToHtmlStringRGB(Color.red) + ">Auto kill is disabled";
						val2.AddMessage(text4);
						val2.sfxLeave.Play(default(Vector3));
					}
				}
			}
			if (Input.GetKeyDown(Plugin.enableLPMKeybind.Value))
			{
				Plugin.LPMEnabled.Value = !Plugin.LPMEnabled.Value;
				PlayerConnectionLog val3 = Object.FindAnyObjectByType<PlayerConnectionLog>();
				if ((Object)(object)val3 != (Object)null)
				{
					if (Plugin.LPMEnabled.Value)
					{
						string text5 = "<color=#" + ColorUtility.ToHtmlStringRGB(Color.green) + ">Low power mode is enabled";
						val3.AddMessage(text5);
						val3.sfxJoin.Play(default(Vector3));
					}
					else
					{
						string text6 = "<color=#" + ColorUtility.ToHtmlStringRGB(Color.red) + ">Low power mode is disabled";
						val3.AddMessage(text6);
						val3.sfxLeave.Play(default(Vector3));
					}
				}
			}
			if (Input.GetKeyDown(Plugin.enableKeybind.Value))
			{
				Plugin.enabled.Value = !Plugin.enabled.Value;
				PlayerConnectionLog val4 = Object.FindAnyObjectByType<PlayerConnectionLog>();
				if ((Object)(object)val4 != (Object)null)
				{
					if (Plugin.enabled.Value)
					{
						string text7 = "<color=#" + ColorUtility.ToHtmlStringRGB(Color.green) + ">Dedicated serverinator is enabled";
						val4.AddMessage(text7);
						val4.sfxJoin.Play(default(Vector3));
					}
					else
					{
						string text8 = "<color=#" + ColorUtility.ToHtmlStringRGB(Color.red) + ">Dedicated serverinator is disabled";
						val4.AddMessage(text8);
						val4.sfxLeave.Play(default(Vector3));
					}
				}
			}
			if (!__instance.character.IsLocal || !PhotonNetwork.IsMasterClient || !__instance.character.inAirport || !Plugin.enabled.Value || !((Object)(object)intHandler == (Object)null))
			{
				return;
			}
			intHandler = ExtGameObject.GetOrAddComponent<IntermissionHandler>(((Component)__instance.character).gameObject);
			if (Plugin.LPMEnabled.Value)
			{
				if (Plugin.LPMDisableParticles.Value)
				{
					ParticleSystem[] array = Object.FindObjectsOfType<ParticleSystem>();
					foreach (ParticleSystem val5 in array)
					{
						val5.Stop(true, (ParticleSystemStopBehavior)0);
					}
				}
				if (Plugin.LPMDisableRendering.Value)
				{
					Renderer[] array2 = Object.FindObjectsOfType<Renderer>();
					foreach (Renderer val6 in array2)
					{
						val6.enabled = false;
					}
				}
			}
			intHandler.fella = __instance.character;
		}
	}
	internal class TheHeartAttackIsComing : MonoBehaviour
	{
		public float timer = -30f;

		public Character character;

		private PlayerConnectionLog pLog;

		public bool warned = false;

		internal void Start()
		{
			pLog = Object.FindAnyObjectByType<PlayerConnectionLog>();
		}

		internal void Update()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.KYSEnabled.Value)
			{
				timer += Time.deltaTime;
				if (timer > -15f && !warned)
				{
					string[] obj = new string[5]
					{
						"<color=#",
						ColorUtility.ToHtmlStringRGB(Color.red),
						">YOU'RE GONNNA DIEEEEEE you have auto kill on so press ",
						null,
						null
					};
					KeyCode value = Plugin.enableKYSKeybind.Value;
					obj[3] = ((object)(KeyCode)(ref value)).ToString();
					obj[4] = " if you dont want that to happen";
					string text = string.Concat(obj);
					pLog.AddMessage(text);
					warned = true;
				}
				if (timer > 3f && !character.inAirport && !character.data.dead && Plugin.KYSEnabled.Value)
				{
					character.DieInstantly();
					timer = 0f;
				}
			}
			else
			{
				warned = false;
				timer = -30f;
			}
		}
	}
	internal class IntermissionHandler : MonoBehaviour
	{
		public float intermission = 0f;

		public Character fella;

		internal void Update()
		{
			if (!fella.inAirport || !fella.IsLocal || !Plugin.enabled.Value)
			{
				return;
			}
			intermission += Time.deltaTime;
			if (intermission > Plugin.intermission.Value)
			{
				AirportCheckInKiosk component = GameObject.Find("AirportGateKiosk").GetComponent<AirportCheckInKiosk>();
				int num = Plugin.maxAscent.Value;
				if (Plugin.randomizeAscent.Value && Plugin.maxAscent.Value > Plugin.minAscent.Value)
				{
					num = Random.Range(Plugin.minAscent.Value, Plugin.maxAscent.Value + 1);
				}
				byte[] serializedRunSettings = RunSettings.GetSerializedRunSettings();
				intermission = 0f;
				((MonoBehaviourPun)component).photonView.RPC("LoadIslandMaster", (RpcTarget)2, new object[2] { num, serializedRunSettings });
			}
		}
	}
	internal class DeathHandler : MonoBehaviour
	{
		public float intermission;

		public Character fella;

		internal void Update()
		{
			if (!fella.IsLocal)
			{
				return;
			}
			intermission += Time.deltaTime;
			if (intermission > Plugin.deathScreenDelay.Value)
			{
				Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
				foreach (Item val in array)
				{
					PhotonNetwork.Destroy(((MonoBehaviourPun)val).photonView);
				}
				TumbleWeed[] array2 = Object.FindObjectsByType<TumbleWeed>((FindObjectsSortMode)0);
				foreach (TumbleWeed val2 in array2)
				{
					PhotonNetwork.Destroy(val2.photonView);
				}
				Singleton<PeakHandler>.Instance.EndScreenComplete();
				intermission = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(Campfire), "Awake")]
	internal static class AddCampfireHandler
	{
		internal static void Prefix(Campfire __instance)
		{
			if (!PhotonNetwork.IsMasterClient || !Plugin.autoCampfire.Value || !(__instance.nameOverride != "NAME_PORTABLE STOVE"))
			{
				return;
			}
			CampfireHandler campfireHandler = ((Component)__instance).gameObject.AddComponent<CampfireHandler>();
			campfireHandler.campfire = __instance;
			if (!Plugin.LPMEnabled.Value)
			{
				return;
			}
			if (Plugin.LPMDisableParticles.Value)
			{
				ParticleSystem[] array = Object.FindObjectsOfType<ParticleSystem>();
				foreach (ParticleSystem val in array)
				{
					val.Stop(true, (ParticleSystemStopBehavior)0);
				}
			}
			if (Plugin.LPMDisableRendering.Value)
			{
				Renderer[] array2 = Object.FindObjectsOfType<Renderer>();
				foreach (Renderer val2 in array2)
				{
					val2.enabled = false;
				}
			}
		}
	}
	internal class StatueHandler : MonoBehaviour
	{
		internal CampfireHandler pairedHandler;

		internal RespawnChest statue;

		public bool popped = false;

		public List<string> HazardNames = new List<string>();

		public void OnEnable()
		{
			((MonoBehaviour)this).StartCoroutine((IEnumerator)CheckForUseRoutine());
		}

		public IEnumerator<WaitForSeconds> CheckForUseRoutine()
		{
			while ((Object)(object)pairedHandler == (Object)null)
			{
				Debug.Log((object)"Attempting to pair...");
				List<CampfireHandler> campHandlers = Object.FindObjectsByType<CampfireHandler>((FindObjectsInactive)1, (FindObjectsSortMode)1).ToList();
				foreach (CampfireHandler c in campHandlers)
				{
					float distance = Vector3.Distance(((Component)c).transform.position, ((Component)this).transform.position);
					if (Singleton<MapHandler>.Instance.currentSegment == 3)
					{
						distance -= 300f;
					}
					if (distance < 100f)
					{
						pairedHandler = c;
						c.pairedStatueHandler = this;
					}
				}
				yield return new WaitForSeconds(1f);
			}
			Debug.Log((object)"Paired!");
			while (true)
			{
				if ((Object)(object)pairedHandler != (Object)null)
				{
					popped = (int)((Luggage)statue).state == 1;
					if (popped)
					{
						Debug.Log((object)"Popped!");
						break;
					}
					if (Plugin.behaviourChosen.Value == Plugin.RespawnStatueBehaviour.AutoTrigger)
					{
						((Luggage)statue).Interact_CastFinished(Character.localCharacter);
						Debug.Log((object)"Popped!");
						break;
					}
					yield return new WaitForSeconds(1f);
				}
				else
				{
					yield return new WaitForSeconds(1f);
				}
			}
			if (!Plugin.clearHazardsAroundStatue.Value)
			{
				yield break;
			}
			for (int i = 0; i < 999; i++)
			{
				RemoveAfterSeconds[] _iHateThisShit = Object.FindObjectsByType<RemoveAfterSeconds>((FindObjectsInactive)0, (FindObjectsSortMode)0);
				RemoveAfterSeconds[] array = _iHateThisShit;
				foreach (RemoveAfterSeconds _i in array)
				{
					if (Vector3.Distance(((Component)this).transform.position, ((Component)_i).transform.position) < Plugin.clearHazardDistance.Value)
					{
						_i.seconds = -1f;
					}
				}
				yield return new WaitForSeconds(1f);
			}
		}
	}
	internal class CampfireHandler : MonoBehaviour
	{
		public float counter;

		public Campfire campfire;

		public bool charsArePresent = false;

		public bool going;

		public StatueHandler pairedStatueHandler = new StatueHandler();

		public void OnEnable()
		{
			addStatueHandlers();
			((MonoBehaviour)this).StartCoroutine((IEnumerator)AutoCampfireCoroutine());
		}

		public IEnumerator<WaitForSeconds> AutoCampfireCoroutine()
		{
			while (true)
			{
				if (PhotonNetwork.IsMasterClient && Plugin.autoCampfire.Value)
				{
					charsArePresent = true;
					if (Plugin.behaviourChosen.Value == Plugin.RespawnStatueBehaviour.WaitForPlayerUse && !pairedStatueHandler.popped)
					{
						charsArePresent = false;
					}
					CheckForPlayers();
					if (Character.AllCharacters.Count < 1)
					{
						charsArePresent = false;
					}
					if (charsArePresent)
					{
						going = true;
					}
					else if (Plugin.autoCampfireTimerReset.Value || Singleton<MapHandler>.Instance.currentSegment == 3)
					{
						counter = 0f;
						going = false;
					}
					if (going)
					{
						counter += 1f;
						int _additionalWaitTime = 0;
						if ((int)Singleton<MapHandler>.Instance.GetCurrentSegment() == 3)
						{
							_additionalWaitTime = 10;
						}
						if (counter > Plugin.autoCampfireDelay.Value + (float)_additionalWaitTime)
						{
							break;
						}
					}
				}
				yield return new WaitForSeconds(1f);
			}
			campfire.view.RPC("Light_Rpc", (RpcTarget)0, Array.Empty<object>());
		}

		public void addStatueHandlers()
		{
			RespawnChest[] array = Object.FindObjectsByType<RespawnChest>((FindObjectsInactive)1, (FindObjectsSortMode)1);
			RespawnChest[] array2 = array;
			foreach (RespawnChest val in array2)
			{
				ExtGameObject.GetOrAddComponent<StatueHandler>(((Component)val).gameObject).statue = val;
			}
		}

		public void CheckForPlayers()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (Vector3.Distance(allCharacter.Center, ((Component)this).transform.position) > Plugin.autoCampfireMinimumDistance.Value && !allCharacter.data.dead)
				{
					charsArePresent = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Item), "Awake")]
	internal static class DoNotLoadItems
	{
		internal static void Prefix(Item __instance)
		{
			if (Plugin.LPMEnabled.Value && Plugin.LPMDisableRendering.Value)
			{
				Renderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>();
				Renderer[] array = componentsInChildren;
				foreach (Renderer val in array)
				{
					val.enabled = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	internal static class DoNotRenderPlayers
	{
		private static void Postfix(Character __instance)
		{
			if (PhotonNetwork.IsMasterClient && __instance.IsLocal)
			{
				((Component)__instance).gameObject.AddComponent<TheHeartAttackIsComing>().character = __instance;
			}
			if (Plugin.LPMEnabled.Value && Plugin.LPMDisableRendering.Value)
			{
				Renderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>();
				Renderer[] array = componentsInChildren;
				foreach (Renderer val in array)
				{
					val.enabled = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(AOE), "Start")]
	internal static class DoNotRenderAoeShit
	{
		private static void Postfix(AOE __instance)
		{
			if (!Plugin.LPMEnabled.Value)
			{
				return;
			}
			if (Plugin.LPMDisableRendering.Value)
			{
				Renderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>();
				Renderer[] array = componentsInChildren;
				foreach (Renderer val in array)
				{
					val.enabled = false;
				}
			}
			if (Plugin.LPMDisableParticles.Value)
			{
				ParticleSystem[] componentsInChildren2 = ((Component)__instance).GetComponentsInChildren<ParticleSystem>();
				ParticleSystem[] array2 = componentsInChildren2;
				foreach (ParticleSystem val2 in array2)
				{
					val2.Stop(true, (ParticleSystemStopBehavior)0);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Tornado), "Start")]
	internal static class DoNotRenderNados
	{
		private static void Postfix(Tornado __instance)
		{
			if (!Plugin.LPMEnabled.Value)
			{
				return;
			}
			if (Plugin.LPMDisableRendering.Value)
			{
				Renderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>();
				Renderer[] array = componentsInChildren;
				foreach (Renderer val in array)
				{
					val.enabled = false;
				}
			}
			if (Plugin.LPMDisableParticles.Value)
			{
				ParticleSystem[] componentsInChildren2 = ((Component)__instance).GetComponentsInChildren<ParticleSystem>();
				ParticleSystem[] array2 = componentsInChildren2;
				foreach (ParticleSystem val2 in array2)
				{
					val2.Stop(true, (ParticleSystemStopBehavior)0);
				}
			}
		}
	}
	[HarmonyPatch(typeof(MobItem), "Awake")]
	internal static class DoNotRenderBots
	{
		private static void Postfix(MobItem __instance)
		{
			if (!Plugin.LPMEnabled.Value)
			{
				return;
			}
			if (Plugin.LPMDisableRendering.Value)
			{
				Renderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>();
				Renderer[] array = componentsInChildren;
				foreach (Renderer val in array)
				{
					val.enabled = false;
				}
			}
			if (Plugin.LPMDisableParticles.Value)
			{
				ParticleSystem[] componentsInChildren2 = ((Component)__instance).GetComponentsInChildren<ParticleSystem>();
				ParticleSystem[] array2 = componentsInChildren2;
				foreach (ParticleSystem val2 in array2)
				{
					val2.Stop(true, (ParticleSystemStopBehavior)0);
				}
			}
		}
	}
	[HarmonyPatch(typeof(TumbleWeed), "Start")]
	internal static class DoNotRenderTumbles
	{
		private static void Postfix(TumbleWeed __instance)
		{
			if (Plugin.LPMEnabled.Value)
			{
				Renderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>();
				Renderer[] array = componentsInChildren;
				foreach (Renderer val in array)
				{
					val.enabled = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(RemoveAfterSeconds), "Start")]
	internal static class DoNotRenderEruptions
	{
		private static void Postfix(RemoveAfterSeconds __instance)
		{
			if (!Plugin.LPMEnabled.Value)
			{
				return;
			}
			if (Plugin.LPMDisableRendering.Value)
			{
				Renderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>();
				Renderer[] array = componentsInChildren;
				foreach (Renderer val in array)
				{
					val.enabled = false;
				}
			}
			if (Plugin.LPMDisableParticles.Value)
			{
				ParticleSystem[] componentsInChildren2 = ((Component)__instance).GetComponentsInChildren<ParticleSystem>();
				ParticleSystem[] array2 = componentsInChildren2;
				foreach (ParticleSystem val2 in array2)
				{
					val2.Stop(true, (ParticleSystemStopBehavior)0);
				}
			}
		}
	}
	[BepInPlugin("dedicatedserverinator", "dedicated serverinator", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal enum RespawnStatueBehaviour
		{
			None = 1,
			WaitForPlayerUse,
			AutoTrigger
		}

		internal static ConfigEntry<bool> randomizeAscent;

		internal static ConfigEntry<int> maxAscent;

		internal static ConfigEntry<int> minAscent;

		internal static ConfigEntry<float> intermission;

		internal static ConfigEntry<float> autoCampfireDelay;

		internal static ConfigEntry<float> autoCampfireMinimumDistance;

		internal static ConfigEntry<float> maxPlayerMagnitude;

		internal static ConfigEntry<bool> autoCampfire;

		internal static ConfigEntry<bool> autoCampfireAdditionalRevive;

		internal static ConfigEntry<bool> alwaysChoosePreviousCampfire;

		internal static ConfigEntry<bool> autoCampfireTimerReset;

		internal static ConfigEntry<float> deathScreenDelay;

		internal static ConfigEntry<bool> instaRestart;

		internal static ConfigEntry<bool> enabled;

		internal static ConfigEntry<KeyCode> enableKeybind;

		internal static ConfigEntry<KeyCode> enableLPMKeybind;

		internal static ConfigEntry<bool> LPMEnabled;

		internal static ConfigEntry<bool> LPMDisableRendering;

		internal static ConfigEntry<bool> LPMDisableParticles;

		internal static ConfigEntry<KeyCode> enableKYSKeybind;

		internal static ConfigEntry<KeyCode> enableAllKeybind;

		internal static ConfigEntry<bool> KYSEnabled;

		internal static ConfigEntry<RespawnStatueBehaviour> behaviourChosen;

		internal static ConfigEntry<bool> clearHazardsAroundStatue;

		internal static ConfigEntry<float> clearHazardDistance;

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			randomizeAscent = ((BaseUnityPlugin)this).Config.Bind<bool>("Ascent", "Randomize Ascent", true, "If set to true the ascent will be randomized based on the minimun and maximum set, if false it will automatically choose the max chosen");
			maxAscent = ((BaseUnityPlugin)this).Config.Bind<int>("Ascent", "Max Ascent", 7, "The max ascent that can be chosen (Both min and max are inclusive)");
			minAscent = ((BaseUnityPlugin)this).Config.Bind<int>("Ascent", "Min Ascent", 0, "The minimum ascent that can be chosen (set to -1 for tenderfoot)");
			intermission = ((BaseUnityPlugin)this).Config.Bind<float>("Intermission", "Intermission", 30f, "How many seconds the game waits until starting another game");
			instaRestart = ((BaseUnityPlugin)this).Config.Bind<bool>("Intermission", "Instant restart", false, "(Currently not functional) If this is set to true a game will instantly be started when all players are dead or have beaten the game without returning to the airport first");
			enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Enable", "Enabled", true, "If set to false nothing in the mod will run");
			enableAllKeybind = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Enable", "Enable/Disable All Bind", (KeyCode)93, (ConfigDescription)null);
			deathScreenDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Intermission", "Death Screen Delay", 20f, "How many seconds the game waits until it sends you back to the airport after winning or losing");
			enableKeybind = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Enable", "Enable Keybind", (KeyCode)112, "Keybind to enable and disable");
			autoCampfire = ((BaseUnityPlugin)this).Config.Bind<bool>("Auto Campfire", "Enable", false, "If set to true the campfire will auto start after the set delay when all players are within the minimum distance");
			autoCampfireDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Auto Campfire", "Auto Campfire Delay", 45f, "How long the campfire waits to auto light after all players are in within distance");
			autoCampfireMinimumDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Auto Campfire", "Auto Campfire Distance", 35f, "How many meters within the campfires radius players have to be in");
			autoCampfireTimerReset = ((BaseUnityPlugin)this).Config.Bind<bool>("Auto Campfire", "Auto Campfire Timer Reset", false, "If set to true the auto campfire timer will stop and reset once a player leaves the radius, good for a large radius");
			enableLPMKeybind = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Low Power Mode", "Enable Keybind", (KeyCode)108, "Keybind to enable and disable low power mode");
			LPMEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Low Power Mode", "Enabled", false, "if false low power mode will not be active");
			LPMDisableParticles = ((BaseUnityPlugin)this).Config.Bind<bool>("Low Power Mode", "Disable Particles", true, "If set to true low power mode will disable most particles");
			LPMDisableRendering = ((BaseUnityPlugin)this).Config.Bind<bool>("Low Power Mode", "Disable Rendering", false, "If set to true low power mode will disable game object rendering");
			enableKYSKeybind = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Auto Self Kill", "Enable Keybind", (KeyCode)107, "Keybind for enabling autokill");
			KYSEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Auto Self Kill", "Enabled", false, "If enabled you will automatically die");
			behaviourChosen = ((BaseUnityPlugin)this).Config.Bind<RespawnStatueBehaviour>("Auto Campfire", "Respawn Statue Behaviour", RespawnStatueBehaviour.None, "Options: None, WaitForPlayerUse, and AutoTrigger");
			clearHazardsAroundStatue = ((BaseUnityPlugin)this).Config.Bind<bool>("Auto Campfire", "Clear Hazards Around Statue When Popped", false, "Clears all hazards around the statue when its popped, this is mainly useful if you have a chaos mod and want players to have a better chance at escaping the statue.");
			clearHazardDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Auto Campfire", "Hazard Clear Distance", 25f, (ConfigDescription)null);
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"Plugin dedicated serverinator is loaded!");
			Harmony val = new Harmony("dsi");
			val.PatchAll();
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}