using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Diversity.Items;
using Diversity.Misc;
using Diversity.Monsters;
using Diversity.Patches;
using Diversity.Player;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Diversity")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Diversity")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("6163c54c-2d5b-4683-ac86-9337d16cc4fd")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
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;
		}
	}
}
public enum Condition
{
	BrokenLeg,
	BrokenArm,
	FracturedLeg,
	FracturedArm,
	Bleeding,
	Blindness,
	Concussed
}
public enum DamageType
{
	GunShotted,
	Mauled,
	Electrified,
	Falling,
	Bitten,
	Concussed,
	Burned,
	Gas
}
namespace Diversity
{
	public class Configuration
	{
		public static ConfigEntry<bool> spiderRevamp;

		public static ConfigEntry<float> spiderSlowAmount;

		public static ConfigEntry<bool> crawlerRevamp;

		public static ConfigEntry<float> crawlerSlowAmount;

		public static ConfigEntry<bool> centipedeRevamp;

		public static ConfigEntry<int> clickAmount;

		public static ConfigEntry<int> hurtChance;

		public static ConfigEntry<bool> brakenRevamp;

		public static ConfigEntry<bool> brakenSpace;

		public static ConfigEntry<float> brakenRange;

		public static ConfigEntry<bool> brakenAnger;

		public static ConfigEntry<float> brakenAngerTime;

		public static ConfigEntry<int> flickerChance;

		public static ConfigEntry<int> breakerChance;

		public static ConfigEntry<bool> apparatusAnger;

		public static ConfigEntry<bool> chaseTriggerer;

		public static ConfigEntry<bool> dressGirlRevamp;

		public static ConfigEntry<float> walkieTalkieFrequency;

		public static ConfigEntry<bool> dressGirlIsolation;

		public static ConfigEntry<bool> playerConditions;

		public static ConfigEntry<bool> fullDarkness;

		public static ConfigEntry<float> fullDarknessIntensity;

		public static ConfigEntry<float> interactRange;

		public static ConfigEntry<bool> fracturedLeg;

		public static ConfigEntry<float> fracturedLegTime;

		public static ConfigEntry<bool> fracturedArm;

		public static ConfigEntry<float> fracturedArmTime;

		public static ConfigEntry<bool> brokenLeg;

		public static ConfigEntry<bool> brokenArm;

		public static ConfigEntry<bool> bleeding;

		public static ConfigEntry<float> bleedingTime;

		public static ConfigEntry<bool> blindness;

		public static ConfigEntry<float> blindnessTime;

		public static ConfigEntry<bool> concussed;

		public static void Load()
		{
			spiderRevamp = Diversity.config.Bind<bool>("Spider", "SpiderRevamp", true, "Should spider revamp be enabled?");
			spiderSlowAmount = Diversity.config.Bind<float>("Spider", "SpiderSlow", 0.8f, "How much slown should spiders be on hit?");
			crawlerRevamp = Diversity.config.Bind<bool>("Crawler", "CrawlerRevamp", true, "Should crawler revamp be enabled?");
			crawlerSlowAmount = Diversity.config.Bind<float>("Crawler", "CrawlerSlow", 0.9f, "How much slown should crawlers be on hit?");
			centipedeRevamp = Diversity.config.Bind<bool>("Centipede", "CentipedeRevamp", true, "Should centipede revamp be enabled?");
			clickAmount = Diversity.config.Bind<int>("Centipede", "ClickAmount", 30, "How many times should you have to click to remove the centipede from someone's head?");
			hurtChance = Diversity.config.Bind<int>("Centipede", "HurtChance", 10, "Chance of hurting the player when trying to free the centipede.");
			brakenRevamp = Diversity.config.Bind<bool>("Bracken", "BrakenRevamp", true, "Should Bracken revamp be enabled?");
			brakenSpace = Diversity.config.Bind<bool>("Bracken", "BrakenPersonnalSpace", true, "Should the Bracken have his own personnal space?");
			brakenRange = Diversity.config.Bind<float>("Bracken", "BrakenRange", 15f, "From how far should the Bracken be able to turn off lights?");
			brakenAnger = Diversity.config.Bind<bool>("Bracken", "BrakenAnger", true, "Should Bracken get angered from the breaker box?");
			brakenAngerTime = Diversity.config.Bind<float>("Bracken", "BrakenAngerTime", 90f, "How long should the Bracken stay angered when fully angered?");
			flickerChance = Diversity.config.Bind<int>("Bracken", "FlickerChance", 100, "Chance on flickering and turning off lights.");
			breakerChance = Diversity.config.Bind<int>("Bracken", "BreakerChance", 75, "Chance for the Bracken to turn off the breaker box.");
			apparatusAnger = Diversity.config.Bind<bool>("Bracken", "ApparatusAnger", true, "Should taking the Apparatus anger the Bracken?");
			chaseTriggerer = Diversity.config.Bind<bool>("Bracken", "ChaseTriggerer", true, "Should the Bracken chase the one who angered him?");
			dressGirlRevamp = Diversity.config.Bind<bool>("Dress Girl", "DressGirlRevamp", true, "Should Dress girl revamp be enabled?");
			walkieTalkieFrequency = Diversity.config.Bind<float>("Dress Girl", "WalkieTalkieFrequency", 1f, "How frequent should the Dress girl haunt the walkie-talkie?");
			dressGirlIsolation = Diversity.config.Bind<bool>("Dress Girl", "DressGirlIsolation", true, "Should Dress girl be able to isolate you and give you hallucinations? (Requires DressGirlRevamp to be enabled.)");
			playerConditions = Diversity.config.Bind<bool>("Player", "PlayerConditions", true, "Should players be able to gain conditions?");
			fullDarkness = Diversity.config.Bind<bool>("Player", "FullDarkness", true, "Should players with no light source be completely in the dark?");
			fullDarknessIntensity = Diversity.config.Bind<float>("Player", "FullDarknessIntensity", 1f, "How intense should full darkness be?");
			interactRange = Diversity.config.Bind<float>("Player", "InteractRange", 3f, "How far can players remove centipede from their head?");
			fracturedLeg = Diversity.config.Bind<bool>("Conditions", "Fractured Leg", true, "Can players fracture their legs? (Will also disable broken legs.)");
			fracturedLegTime = Diversity.config.Bind<float>("Conditions", "Fractured Leg Time", 60f, "How long should fractured legs last?");
			fracturedArm = Diversity.config.Bind<bool>("Conditions", "Fractured Arm", true, "Can players fracture their arms? (Will also disable broken arms.");
			fracturedArmTime = Diversity.config.Bind<float>("Conditions", "Fractured Arm Time", 60f, "How long should fractured arms last?");
			brokenLeg = Diversity.config.Bind<bool>("Conditions", "Broken Leg", true, "Can players break their legs?");
			brokenArm = Diversity.config.Bind<bool>("Conditions", "Broken Arm", true, "Can players break their arms?");
			bleeding = Diversity.config.Bind<bool>("Conditions", "Bleeding", true, "Can players bleed?");
			bleedingTime = Diversity.config.Bind<float>("Conditions", "Bleeding Time", 300f, "How long should bleeding last?");
			blindness = Diversity.config.Bind<bool>("Conditions", "Blindness", true, "Can players be blinded?");
			blindnessTime = Diversity.config.Bind<float>("Conditions", "Blindness Time", 30f, "How long should blindness last? (in seconds)");
			concussed = Diversity.config.Bind<bool>("Conditions", "Concussed", true, "Can players concussed?");
		}
	}
	public class Content
	{
		public static AssetBundle MainAssets;

		public static void TryLoadAssets()
		{
			if ((Object)(object)MainAssets == (Object)null)
			{
				MainAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "diversity"));
				Diversity.mls.LogInfo((object)"Loaded asset bundle!");
			}
		}
	}
	public class DiversityAssets : MonoBehaviour
	{
		[Serializable]
		public class RandomSoundAudioClip
		{
			public DiversitySoundManager.SoundType soundType;

			public AudioClip[] audioClips;
		}

		[Serializable]
		public class SoundAudioClip
		{
			public DiversitySoundManager.SoundType soundType;

			public AudioClip audioClip;
		}

		public SoundAudioClip[] soundAudioClipArray;

		public RandomSoundAudioClip[] randomSoundAudioClipArray;

		public static DiversityAssets Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
	public class DiversitySoundManager : MonoBehaviour
	{
		public enum SoundType
		{
			SteamLeak,
			LightOn,
			LightBuzz,
			Ambience,
			Fracture,
			BrokenBone,
			Hurt,
			BrackenScream,
			BrackenSpeech,
			DressGirlSpeech,
			DressGirlVoices,
			HeartBeat,
			DoorSlam,
			WalkerFootStep
		}

		public static GameObject oneShot;

		public static AudioSource oneShotAudio;

		public static GameObject oneShotBypass;

		public static AudioSource oneShotAudioBypass;

		public List<GameObject> current3Daudios = new List<GameObject>();

		public List<GameObject> currentGirlAudios = new List<GameObject>();

		public static DiversitySoundManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public static void PlaySound(SoundType soundType, bool random, float volume, float pan, bool loop, Vector3 position)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			AudioMixerGroup outputAudioMixerGroup = SoundManager.Instance.diageticMixer.FindMatchingGroups("SFX")[0];
			GameObject val = new GameObject("Sound");
			val.transform.position = position;
			AudioSource val2 = val.AddComponent<AudioSource>();
			val2.spatialBlend = 1f;
			val2.playOnAwake = false;
			val2.dopplerLevel = 0f;
			val2.spread = 70f;
			val2.reverbZoneMix = 1f;
			val2.outputAudioMixerGroup = outputAudioMixerGroup;
			val2.loop = loop;
			val2.panStereo = pan;
			if (random)
			{
				val2.clip = GetRandomAudioClipByType(soundType);
			}
			else
			{
				val2.clip = GetAudioClipByType(soundType);
			}
			val2.rolloffMode = (AudioRolloffMode)1;
			if (soundType == SoundType.LightOn)
			{
				val2.maxDistance = 100f;
			}
			else if (soundType == SoundType.SteamLeak || soundType == SoundType.LightBuzz)
			{
				val2.maxDistance = 32f;
			}
			else
			{
				val2.maxDistance = 32f;
			}
			val2.volume = volume;
			val2.Play();
			if (soundType == SoundType.DressGirlSpeech)
			{
				Instance.currentGirlAudios.Add(val);
			}
			else if (!loop)
			{
				Object.Destroy((Object)(object)val, val2.clip.length);
			}
			else
			{
				Instance.current3Daudios.Add(val);
			}
		}

		public static void PlaySound(SoundType soundType, bool random, float volume, float pan)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			AudioMixerGroup outputAudioMixerGroup = SoundManager.Instance.diageticMixer.FindMatchingGroups("SFX")[0];
			if ((Object)(object)oneShot == (Object)null)
			{
				oneShot = new GameObject("OneShotSound");
				oneShotAudio = oneShot.AddComponent<AudioSource>();
			}
			oneShotAudio.outputAudioMixerGroup = outputAudioMixerGroup;
			oneShotAudio.panStereo = pan;
			if (random)
			{
				oneShotAudio.PlayOneShot(GetRandomAudioClipByType(soundType), volume);
			}
			else
			{
				oneShotAudio.PlayOneShot(GetAudioClipByType(soundType), volume);
			}
		}

		public static void DeleteAudio(GameObject audio)
		{
			Object.Destroy((Object)(object)audio);
		}

		public static void PlaySoundBypass(SoundType soundType, bool random, float volume, float pan, bool loop, Vector3 position)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Sound");
			val.transform.position = position;
			AudioSource val2 = val.AddComponent<AudioSource>();
			val2.spatialBlend = 1f;
			val2.playOnAwake = false;
			val2.dopplerLevel = 0f;
			val2.spread = 70f;
			val2.reverbZoneMix = 1f;
			val2.bypassListenerEffects = true;
			val2.loop = loop;
			val2.panStereo = pan;
			if (random)
			{
				val2.clip = GetRandomAudioClipByType(soundType);
			}
			else
			{
				val2.clip = GetAudioClipByType(soundType);
			}
			val2.rolloffMode = (AudioRolloffMode)1;
			if (soundType == SoundType.LightOn)
			{
				val2.maxDistance = 100f;
			}
			else if (soundType == SoundType.SteamLeak || soundType == SoundType.LightBuzz)
			{
				val2.maxDistance = 32f;
			}
			else
			{
				val2.maxDistance = 32f;
			}
			val2.volume = volume;
			val2.Play();
			if (soundType == SoundType.DressGirlSpeech)
			{
				Instance.currentGirlAudios.Add(val);
			}
			else if (!loop)
			{
				Object.Destroy((Object)(object)val, val2.clip.length);
			}
			else
			{
				Instance.current3Daudios.Add(val);
			}
		}

		public static void PlaySoundBypass(SoundType soundType, bool random, float volume = 1f, float pan = 1f)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if ((Object)(object)oneShotBypass == (Object)null)
			{
				oneShotBypass = new GameObject("OneShotSound");
				oneShotAudioBypass = oneShotBypass.AddComponent<AudioSource>();
				oneShotAudioBypass.bypassListenerEffects = true;
			}
			oneShotAudioBypass.panStereo = pan;
			if (random)
			{
				oneShotAudioBypass.PlayOneShot(GetRandomAudioClipByType(soundType), volume);
			}
			else
			{
				oneShotAudioBypass.PlayOneShot(GetAudioClipByType(soundType), volume);
			}
		}

		public static void StopSound()
		{
			if ((Object)(object)oneShot != (Object)null)
			{
				oneShotAudio.Stop();
			}
		}

		public static void StopSoundBypass()
		{
			if ((Object)(object)oneShot != (Object)null)
			{
				oneShotAudioBypass.Stop();
			}
		}

		public static Vector3 CheckPosition(PlayerControllerB player)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)player))
			{
				if (!player.isPlayerDead)
				{
					return ((Component)player.gameplayCamera).transform.position;
				}
				return player.spectateCameraPivot.position;
			}
			return Vector3.zero;
		}

		private static AudioClip GetAudioClipByType(SoundType soundType)
		{
			Diversity.mls.LogInfo((object)DiversityAssets.Instance.soundAudioClipArray);
			DiversityAssets.SoundAudioClip[] soundAudioClipArray = DiversityAssets.Instance.soundAudioClipArray;
			foreach (DiversityAssets.SoundAudioClip soundAudioClip in soundAudioClipArray)
			{
				if (soundAudioClip.soundType == soundType)
				{
					return soundAudioClip.audioClip;
				}
			}
			Diversity.mls.LogError((object)("No audio of type:" + soundType));
			return null;
		}

		private static AudioClip GetRandomAudioClipByType(SoundType soundType)
		{
			DiversityAssets.RandomSoundAudioClip[] randomSoundAudioClipArray = DiversityAssets.Instance.randomSoundAudioClipArray;
			foreach (DiversityAssets.RandomSoundAudioClip randomSoundAudioClip in randomSoundAudioClipArray)
			{
				if (randomSoundAudioClip.soundType == soundType)
				{
					return randomSoundAudioClip.audioClips[Random.Range(0, randomSoundAudioClip.audioClips.Length)];
				}
			}
			Diversity.mls.LogError((object)("No audio of type:" + soundType));
			return null;
		}
	}
	[BepInPlugin("Chaos.Diversity", "Diversity", "1.1.10")]
	public class Diversity : BaseUnityPlugin
	{
		private const string modGUID = "Chaos.Diversity";

		private const string modName = "Diversity";

		private const string modVersion = "1.1.10";

		private readonly Harmony harmony = new Harmony("Chaos.Diversity");

		public static Diversity Instance;

		public static ManualLogSource mls;

		public static ConfigFile config;

		public static EnemyType longBoiType;

		private void Awake()
		{
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = ((BaseUnityPlugin)this).Logger;
			config = ((BaseUnityPlugin)this).Config;
			Configuration.Load();
			Content.TryLoadAssets();
			harmony.PatchAll(typeof(BaboonBirdAIPatch));
			harmony.PatchAll(typeof(BlobAIPatch));
			harmony.PatchAll(typeof(BreakerBoxPatch));
			harmony.PatchAll(typeof(CentipedeAIPatch));
			harmony.PatchAll(typeof(CrawlerAIPatch));
			harmony.PatchAll(typeof(DressGirlAIPatch));
			harmony.PatchAll(typeof(FlashlightPatch));
			harmony.PatchAll(typeof(FlowermanAIPatch));
			harmony.PatchAll(typeof(HoarderBugAIPatch));
			harmony.PatchAll(typeof(HUDPatch));
			harmony.PatchAll(typeof(LungPropPatch));
			harmony.PatchAll(typeof(ManualCameraRendererPatch));
			harmony.PatchAll(typeof(PlayerControllerBPatch));
			harmony.PatchAll(typeof(PufferAIPatch));
			harmony.PatchAll(typeof(RadarBoosterItemPatch));
			harmony.PatchAll(typeof(RedLocustBeesPatch));
			harmony.PatchAll(typeof(RoundManagerPatch));
			harmony.PatchAll(typeof(SandSpiderAIPatch));
			harmony.PatchAll(typeof(ShipTeleporterPatch));
			harmony.PatchAll(typeof(SoundManagerPatch));
			harmony.PatchAll(typeof(SpringManAIPatch));
			harmony.PatchAll(typeof(StartOfRoundPatch));
			harmony.PatchAll(typeof(SteamValveHazardPatch));
			harmony.PatchAll(typeof(Diversity));
			longBoiType = Content.MainAssets.LoadAsset<EnemyType>("Assets/custom/diversity/walker/WalkerType.asset");
			GameObject val = new GameObject("DiversitySoundManagerAssets");
			val.AddComponent<DiversitySoundManager>();
			DiversityAssets diversityAssets = val.AddComponent<DiversityAssets>();
			diversityAssets.soundAudioClipArray = new DiversityAssets.SoundAudioClip[4];
			diversityAssets.randomSoundAudioClipArray = new DiversityAssets.RandomSoundAudioClip[6];
			DiversityAssets.SoundAudioClip soundAudioClip = new DiversityAssets.SoundAudioClip();
			soundAudioClip.soundType = DiversitySoundManager.SoundType.SteamLeak;
			soundAudioClip.audioClip = Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/bracken/rooms/audio/steam.ogg");
			DiversityAssets.SoundAudioClip soundAudioClip2 = new DiversityAssets.SoundAudioClip();
			soundAudioClip2.soundType = DiversitySoundManager.SoundType.LightOn;
			soundAudioClip2.audioClip = Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/bracken/rooms/audio/lighton.ogg");
			DiversityAssets.SoundAudioClip soundAudioClip3 = new DiversityAssets.SoundAudioClip();
			soundAudioClip3.soundType = DiversitySoundManager.SoundType.LightBuzz;
			soundAudioClip3.audioClip = Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/bracken/rooms/audio/lightbuzz.ogg");
			DiversityAssets.SoundAudioClip soundAudioClip4 = new DiversityAssets.SoundAudioClip();
			soundAudioClip4.soundType = DiversitySoundManager.SoundType.HeartBeat;
			soundAudioClip4.audioClip = Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/player/audio/heartbeat.ogg");
			DiversityAssets.RandomSoundAudioClip randomSoundAudioClip = new DiversityAssets.RandomSoundAudioClip();
			AudioClip[] audioClips = (AudioClip[])(object)new AudioClip[1] { Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/bracken/ambience.ogg") };
			randomSoundAudioClip.soundType = DiversitySoundManager.SoundType.Ambience;
			randomSoundAudioClip.audioClips = audioClips;
			DiversityAssets.RandomSoundAudioClip randomSoundAudioClip2 = new DiversityAssets.RandomSoundAudioClip();
			AudioClip[] audioClips2 = (AudioClip[])(object)new AudioClip[1] { Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/bracken/brakenScream.mp3") };
			randomSoundAudioClip2.soundType = DiversitySoundManager.SoundType.BrackenScream;
			randomSoundAudioClip2.audioClips = audioClips2;
			DiversityAssets.RandomSoundAudioClip randomSoundAudioClip3 = new DiversityAssets.RandomSoundAudioClip();
			AudioClip[] audioClips3 = (AudioClip[])(object)new AudioClip[1] { Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/bracken/you're next.mp3") };
			randomSoundAudioClip3.soundType = DiversitySoundManager.SoundType.BrackenSpeech;
			randomSoundAudioClip3.audioClips = audioClips3;
			DiversityAssets.RandomSoundAudioClip randomSoundAudioClip4 = new DiversityAssets.RandomSoundAudioClip();
			AudioClip[] audioClips4 = (AudioClip[])(object)new AudioClip[17]
			{
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 1.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 2.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 3.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 4.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 5.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 6.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 7.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 8.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 9.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 10.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 11.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 12.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 14.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 15.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 16.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 17.wav"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/girl/voice/voice_Insert 18.wav")
			};
			randomSoundAudioClip4.soundType = DiversitySoundManager.SoundType.DressGirlSpeech;
			randomSoundAudioClip4.audioClips = audioClips4;
			DiversityAssets.RandomSoundAudioClip randomSoundAudioClip5 = new DiversityAssets.RandomSoundAudioClip();
			AudioClip[] audioClips5 = (AudioClip[])(object)new AudioClip[4]
			{
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/walker/audios/footsteps/step1.ogg"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/walker/audios/footsteps/step2.ogg"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/walker/audios/footsteps/step3.ogg"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/walker/audios/footsteps/step4.ogg")
			};
			randomSoundAudioClip5.soundType = DiversitySoundManager.SoundType.WalkerFootStep;
			randomSoundAudioClip5.audioClips = audioClips5;
			DiversityAssets.RandomSoundAudioClip randomSoundAudioClip6 = new DiversityAssets.RandomSoundAudioClip();
			AudioClip[] audioClips6 = (AudioClip[])(object)new AudioClip[2]
			{
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/walker/audios/DoorBash/DoorSlam1.ogg"),
				Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/walker/audios/DoorBash/DoorSlam2.ogg")
			};
			randomSoundAudioClip6.soundType = DiversitySoundManager.SoundType.DoorSlam;
			randomSoundAudioClip6.audioClips = audioClips6;
			diversityAssets.soundAudioClipArray[0] = soundAudioClip;
			diversityAssets.soundAudioClipArray[1] = soundAudioClip2;
			diversityAssets.soundAudioClipArray[2] = soundAudioClip3;
			diversityAssets.soundAudioClipArray[3] = soundAudioClip4;
			diversityAssets.randomSoundAudioClipArray[0] = randomSoundAudioClip;
			diversityAssets.randomSoundAudioClipArray[1] = randomSoundAudioClip2;
			diversityAssets.randomSoundAudioClipArray[2] = randomSoundAudioClip3;
			diversityAssets.randomSoundAudioClipArray[3] = randomSoundAudioClip4;
			diversityAssets.randomSoundAudioClipArray[4] = randomSoundAudioClip6;
			diversityAssets.randomSoundAudioClipArray[5] = randomSoundAudioClip5;
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)val);
			mls.LogInfo((object)"Diversity started.");
		}
	}
	public class DiversityBehaviour : MonoBehaviour
	{
		public int anger = 3;

		private void Update()
		{
		}
	}
}
namespace Diversity.Player
{
	public class PlayerRevamp : MonoBehaviour
	{
		public List<Condition> conditions = new List<Condition>();

		public bool isHaunted = false;

		public bool dressGirlHaunt = false;

		public Light lastLight;

		public int lastID = 0;

		public bool kidnapped = false;

		public float filter = 0f;

		public float dressGirlHauntTime = 0f;

		public float heartBeatInterval = 1f;

		public float voicesTime = 0f;

		public float voicesInterval = 1f;

		public float heartBeatTime = 0f;

		public float heartBeatCooldown = 0f;

		private static float timeElapsed;

		private bool fullDarknessSet = false;

		private bool playersHidden = false;

		public List<Vector3> nearbySounds = new List<Vector3>();

		private float timeFracturedLeg = 0f;

		private float timeFracturedArm = 0f;

		private float timeBleeding = 0f;

		private float timeBlinded = 0f;

		private float soundCheckInterval = 0f;

		private bool instanciated = false;

		public bool updated = false;

		private bool unfinished = false;

		public bool sinkingFromWalker = false;

		private bool currentlySinking = false;

		private float sinkingTime = 0f;

		public bool forceLook = false;

		public Vector3 forceLookPosition = Vector3.zero;

		public void ApplyConditions(DamageType damageType, float modifier)
		{
			Diversity.mls.LogInfo((object)("Player took damage type: " + damageType));
			if (damageType == DamageType.Falling && Configuration.fracturedLeg.Value)
			{
				float value = Random.value;
				if (value <= 0.1f * modifier)
				{
					bool flag = false;
					foreach (Condition condition in conditions)
					{
						if (condition == Condition.FracturedLeg)
						{
							flag = true;
						}
					}
					if (!flag)
					{
						conditions.Add(Condition.FracturedLeg);
						Diversity.mls.LogInfo((object)("Player just received condition:" + Condition.FracturedLeg));
					}
					else if (Configuration.brokenLeg.Value)
					{
						bool flag2 = false;
						foreach (Condition condition2 in conditions)
						{
							if (condition2 == Condition.BrokenLeg)
							{
								flag2 = true;
							}
						}
						if (!flag2)
						{
							conditions.Remove(Condition.FracturedLeg);
							Diversity.mls.LogInfo((object)("Player just lost condition:" + Condition.FracturedLeg));
							conditions.Add(Condition.BrokenLeg);
							Diversity.mls.LogInfo((object)("Player just received condition:" + Condition.BrokenLeg));
						}
					}
				}
			}
			else if ((damageType == DamageType.GunShotted || damageType == DamageType.Mauled || damageType == DamageType.Bitten) && Configuration.bleeding.Value)
			{
				float value2 = Random.value;
				if (value2 <= 0.15f * modifier || damageType == DamageType.GunShotted)
				{
					bool flag3 = false;
					foreach (Condition condition3 in conditions)
					{
						if (condition3 == Condition.Bleeding)
						{
							flag3 = true;
						}
					}
					if (!flag3)
					{
						conditions.Add(Condition.Bleeding);
						Diversity.mls.LogInfo((object)("Player just received condition:" + Condition.Bleeding));
					}
				}
			}
			if (damageType == DamageType.Mauled && Configuration.fracturedArm.Value)
			{
				float value3 = Random.value;
				if (value3 <= 0.15f * modifier)
				{
					bool flag4 = false;
					foreach (Condition condition4 in conditions)
					{
						if (condition4 == Condition.FracturedArm)
						{
							flag4 = true;
						}
					}
					if (!flag4)
					{
						conditions.Add(Condition.FracturedArm);
						Diversity.mls.LogInfo((object)("Player just received condition:" + Condition.FracturedArm));
					}
					if (flag4 && value3 <= 0.05f && Configuration.brokenArm.Value)
					{
						bool flag5 = false;
						foreach (Condition condition5 in conditions)
						{
							if (condition5 == Condition.BrokenArm)
							{
								flag5 = true;
							}
						}
						if (!flag5)
						{
							conditions.Remove(Condition.FracturedArm);
							Diversity.mls.LogInfo((object)("Player just lost condition:" + Condition.FracturedArm));
							conditions.Add(Condition.BrokenArm);
							Diversity.mls.LogInfo((object)("Player just received condition:" + Condition.BrokenArm));
						}
					}
				}
			}
			if (damageType == DamageType.Gas && Configuration.blindness.Value)
			{
				float value4 = Random.value;
				if (value4 <= 0.15f * modifier)
				{
					bool flag6 = false;
					foreach (Condition condition6 in conditions)
					{
						if (condition6 == Condition.Blindness)
						{
							flag6 = true;
						}
					}
					if (!flag6)
					{
						conditions.Add(Condition.Blindness);
						Diversity.mls.LogInfo((object)("Player just received condition:" + Condition.Blindness));
					}
				}
			}
			if (damageType != DamageType.Concussed || !Configuration.concussed.Value)
			{
				return;
			}
			float value5 = Random.value;
			if (!(value5 <= 0.35f * modifier))
			{
				return;
			}
			bool flag7 = false;
			foreach (Condition condition7 in conditions)
			{
				if (condition7 == Condition.Concussed)
				{
					flag7 = true;
				}
			}
			if (!flag7)
			{
				conditions.Add(Condition.Concussed);
				Diversity.mls.LogInfo((object)("Player just received condition:" + Condition.Concussed));
			}
		}

		public void CheckConditions(PlayerControllerB player)
		{
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			if (!Configuration.playerConditions.Value || !player.AllowPlayerDeath())
			{
				return;
			}
			using List<Condition>.Enumerator enumerator = conditions.ToList().GetEnumerator();
			while (enumerator.MoveNext())
			{
				switch (enumerator.Current)
				{
				case Condition.FracturedLeg:
					if (((NetworkBehaviour)player).IsOwner)
					{
						timeFracturedLeg += Time.deltaTime;
						if (timeFracturedLeg >= Configuration.fracturedLegTime.Value)
						{
							timeFracturedLeg = 0f;
							player.jumpForce = 13f;
							conditions.Remove(Condition.FracturedLeg);
						}
						else
						{
							player.jumpForce = 10f;
						}
					}
					break;
				case Condition.BrokenLeg:
					if (((NetworkBehaviour)player).IsOwner)
					{
						player.playerBodyAnimator.SetBool("Limp", true);
						player.jumpForce = 9f;
					}
					break;
				case Condition.FracturedArm:
					if ((Object)(object)player.currentlyHeldObject != (Object)null)
					{
						timeFracturedArm += Time.deltaTime;
						if (timeFracturedArm >= Configuration.fracturedArmTime.Value)
						{
							conditions.Remove(Condition.FracturedArm);
							timeFracturedArm = 0f;
						}
						GrabbableObject currentlyHeldObject2 = player.currentlyHeldObject;
						if (((NetworkBehaviour)player).IsOwner)
						{
							Item itemProperties3 = currentlyHeldObject2.itemProperties;
							if (itemProperties3.weight > 25f)
							{
								player.DiscardHeldObject(false, (NetworkObject)null, default(Vector3), true);
							}
						}
					}
					else
					{
						if (!((Object)(object)player.currentlyHeldObjectServer != (Object)null))
						{
							break;
						}
						GrabbableObject currentlyHeldObjectServer2 = player.currentlyHeldObjectServer;
						if (((NetworkBehaviour)player).IsOwner)
						{
							Item itemProperties4 = currentlyHeldObjectServer2.itemProperties;
							if (itemProperties4.weight > 25f)
							{
								player.DiscardHeldObject(false, (NetworkObject)null, default(Vector3), true);
							}
						}
					}
					break;
				case Condition.BrokenArm:
					if ((Object)(object)player.currentlyHeldObject != (Object)null)
					{
						GrabbableObject currentlyHeldObject = player.currentlyHeldObject;
						if (((NetworkBehaviour)player).IsOwner)
						{
							Item itemProperties = currentlyHeldObject.itemProperties;
							if (itemProperties.weight > 15f)
							{
								player.DiscardHeldObject(false, (NetworkObject)null, default(Vector3), true);
							}
						}
					}
					else
					{
						if (!((Object)(object)player.currentlyHeldObjectServer != (Object)null))
						{
							break;
						}
						GrabbableObject currentlyHeldObjectServer = player.currentlyHeldObjectServer;
						if (((NetworkBehaviour)player).IsOwner)
						{
							Item itemProperties2 = currentlyHeldObjectServer.itemProperties;
							if (itemProperties2.weight > 15f)
							{
								player.DiscardHeldObject(false, (NetworkObject)null, default(Vector3), true);
							}
						}
					}
					break;
				case Condition.Bleeding:
					if (((NetworkBehaviour)player).IsOwner)
					{
						timeBleeding += Time.deltaTime;
						if (timeBleeding >= Configuration.bleedingTime.Value)
						{
							timeBleeding = 0f;
							player.bleedingHeavily = false;
							conditions.Remove(Condition.Bleeding);
						}
						else
						{
							player.healthRegenerateTimer = 1f;
							player.bleedingHeavily = true;
						}
					}
					break;
				case Condition.Blindness:
				{
					if (!((NetworkBehaviour)player).IsOwner)
					{
						break;
					}
					PlayerControllerB localPlayerController2 = StartOfRound.Instance.localPlayerController;
					if (Object.op_Implicit((Object)(object)localPlayerController2) && (localPlayerController2.playerSteamId == player.playerSteamId || localPlayerController2.actualClientId == player.actualClientId))
					{
						HUDManagerRevamp component2 = ((Component)HUDManager.Instance).gameObject.GetComponent<HUDManagerRevamp>();
						if (!Object.op_Implicit((Object)(object)component2))
						{
							return;
						}
						timeBlinded += Time.deltaTime;
						Diversity.mls.LogInfo((object)(timeBlinded + " >= " + Configuration.blindnessTime.Value));
						if (timeBlinded >= Configuration.blindnessTime.Value)
						{
							timeBlinded = 0f;
							component2.blindnessIntensity = 0f;
							conditions.Remove(Condition.Blindness);
						}
						else
						{
							component2.blindnessIntensity = 1f;
						}
					}
					break;
				}
				case Condition.Concussed:
				{
					if (!((NetworkBehaviour)player).IsOwner)
					{
						break;
					}
					PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
					if (Object.op_Implicit((Object)(object)localPlayerController) && (localPlayerController.playerSteamId == player.playerSteamId || localPlayerController.actualClientId == player.actualClientId))
					{
						HUDManagerRevamp component = ((Component)HUDManager.Instance).gameObject.GetComponent<HUDManagerRevamp>();
						if (!Object.op_Implicit((Object)(object)component))
						{
							return;
						}
						component.concussedIntensity = 1f;
					}
					break;
				}
				}
			}
		}

		private void OnTriggerEnter(Collider col)
		{
			if (((Object)((Component)col).gameObject).name == "RoomCollider" && !updated)
			{
				BrakenRevamp[] array = Object.FindObjectsOfType<BrakenRevamp>();
				BrakenRevamp[] array2 = array;
				foreach (BrakenRevamp brakenRevamp in array2)
				{
					brakenRevamp.kidnapped = true;
				}
				kidnapped = true;
				updated = true;
			}
		}

		private void Update()
		{
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_0595: Unknown result type (might be due to invalid IL or missing references)
			//IL_059a: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0707: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0803: Unknown result type (might be due to invalid IL or missing references)
			//IL_0806: Unknown result type (might be due to invalid IL or missing references)
			//IL_080f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0720: Unknown result type (might be due to invalid IL or missing references)
			//IL_072f: Unknown result type (might be due to invalid IL or missing references)
			//IL_094a: Unknown result type (might be due to invalid IL or missing references)
			//IL_075f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0777: Unknown result type (might be due to invalid IL or missing references)
			//IL_0963: Unknown result type (might be due to invalid IL or missing references)
			//IL_0972: Unknown result type (might be due to invalid IL or missing references)
			//IL_0863: Unknown result type (might be due to invalid IL or missing references)
			//IL_087c: Unknown result type (might be due to invalid IL or missing references)
			//IL_088b: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d3: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB component = ((Component)this).gameObject.GetComponent<PlayerControllerB>();
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			HUDManagerRevamp component2 = ((Component)HUDManager.Instance).gameObject.GetComponent<HUDManagerRevamp>();
			if (!Object.op_Implicit((Object)(object)component2) || !Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			if (component.isPlayerDead)
			{
				dressGirlHaunt = false;
			}
			if (Configuration.fullDarkness.Value && (Object)(object)component == (Object)(object)localPlayerController && !fullDarknessSet)
			{
				Diversity.mls.LogInfo((object)("Setting full darkness to local player: " + component.playerUsername));
				component.nightVision.intensity = 366.9317f * (1f - Configuration.fullDarknessIntensity.Value);
				fullDarknessSet = true;
			}
			if (Configuration.dressGirlRevamp.Value && Configuration.dressGirlIsolation.Value)
			{
				if (dressGirlHaunt && component.actualClientId == localPlayerController.actualClientId && !component.isPlayerDead)
				{
					heartBeatTime += Time.deltaTime;
					heartBeatCooldown += Time.deltaTime;
					dressGirlHauntTime += Time.deltaTime;
					voicesTime += Time.deltaTime;
					component2.black.weight = Mathf.Lerp(0f, 1f, dressGirlHauntTime / 19f);
					filter = Mathf.Lerp(0f, 1f, dressGirlHauntTime / 19f);
					if (!playersHidden)
					{
						PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
						foreach (PlayerControllerB val in allPlayerScripts)
						{
							if ((Object)(object)val != (Object)null && val.actualClientId != StartOfRound.Instance.localPlayerController.actualClientId)
							{
								((Component)val).gameObject.SetActive(false);
							}
						}
					}
					heartBeatInterval = Mathf.Lerp(1.5f, 0.5f, dressGirlHauntTime / 19f);
					voicesInterval = Mathf.Lerp(3f, 0.75f, dressGirlHauntTime / 19f);
					if (heartBeatTime >= heartBeatInterval)
					{
						DiversitySoundManager.PlaySoundBypass(DiversitySoundManager.SoundType.HeartBeat, random: false, 1f, 0f);
						heartBeatTime = 0f;
					}
					if (voicesTime >= voicesInterval)
					{
						DiversitySoundManager.PlaySoundBypass(DiversitySoundManager.SoundType.DressGirlSpeech, random: true, Mathf.Lerp(0.6f, 0f, dressGirlHauntTime / 15f), 0f, loop: false, RoundManager.Instance.GetRandomPositionInRadius(((Component)component).transform.position, 6f, 11f, (Random)null));
						voicesTime = 0f;
					}
					playersHidden = true;
				}
				else if ((Object)(object)component == (Object)(object)localPlayerController && !dressGirlHaunt)
				{
					dressGirlHauntTime = 0f;
					component2.black.weight = 0f;
					component2.hauntedIntensity = 0f;
					filter = 0f;
					heartBeatTime = 0f;
					heartBeatCooldown = 0f;
					heartBeatInterval = 1f;
					voicesInterval = 1f;
					voicesTime = 0f;
					if (playersHidden)
					{
						PlayerControllerB[] allPlayerScripts2 = StartOfRound.Instance.allPlayerScripts;
						foreach (PlayerControllerB val2 in allPlayerScripts2)
						{
							if ((Object)(object)val2 != (Object)null && val2.actualClientId != StartOfRound.Instance.localPlayerController.actualClientId)
							{
								((Component)val2).gameObject.SetActive(true);
							}
						}
					}
					playersHidden = false;
				}
			}
			if (sinkingFromWalker)
			{
				sinkingTime += Time.deltaTime;
				if (sinkingTime > 8f)
				{
					sinkingTime = 8f;
				}
				component2.black.weight = Mathf.Lerp(0f, 1f, sinkingTime / 8f);
				filter = Mathf.Lerp(0f, 1f, sinkingTime / 8f);
			}
			else if (!dressGirlHaunt)
			{
				sinkingTime -= Time.deltaTime;
				if (sinkingTime > 5f)
				{
					sinkingTime = 5f;
				}
				else if (sinkingTime < 0f)
				{
					sinkingTime = 0f;
				}
				component2.black.weight = Mathf.Lerp(0f, 1f, sinkingTime / 5f);
				filter = Mathf.Lerp(0f, 1f, sinkingTime / 5f);
			}
			if (!component.isPlayerControlled)
			{
				return;
			}
			if (forceLook)
			{
				Vector3 val3 = forceLookPosition - ((Component)component.gameplayCamera).transform.position;
				Vector3 val4 = ((Component)component.gameplayCamera).transform.InverseTransformDirection(val3);
				Vector2 val5 = default(Vector2);
				((Vector2)(ref val5))..ctor(val4.x, val4.y);
				component.CalculateNormalLookingInput(val5);
			}
			soundCheckInterval += Time.deltaTime;
			if (soundCheckInterval >= 0.5f)
			{
				if (!Object.op_Implicit((Object)(object)StartOfRoundRevamp.Instance) || !Object.op_Implicit((Object)(object)StartOfRound.Instance) || !Object.op_Implicit((Object)(object)StartOfRound.Instance.localPlayerController))
				{
					return;
				}
				foreach (GameObject item in StartOfRoundRevamp.Instance.steamSounds.ToList())
				{
					if (!Object.op_Implicit((Object)(object)item))
					{
						return;
					}
					bool flag = false;
					foreach (Vector3 item2 in nearbySounds.ToList())
					{
						if (item2 == item.transform.position)
						{
							flag = true;
						}
					}
					if (!flag && !instanciated)
					{
						DiversitySoundManager.CheckPosition(StartOfRound.Instance.localPlayerController);
						if (false)
						{
							return;
						}
						float num = Vector3.Distance(item.transform.position, DiversitySoundManager.CheckPosition(StartOfRound.Instance.localPlayerController));
						if (num < 32f)
						{
							DiversitySoundManager.PlaySound(DiversitySoundManager.SoundType.SteamLeak, random: false, 0.1f, 0f, loop: true, item.transform.position);
							nearbySounds.Add(item.transform.position);
							instanciated = true;
						}
					}
				}
				foreach (GameObject item3 in StartOfRoundRevamp.Instance.lightBuzz.ToList())
				{
					if (!Object.op_Implicit((Object)(object)item3))
					{
						return;
					}
					bool flag2 = false;
					foreach (Vector3 item4 in nearbySounds.ToList())
					{
						if (item4 == item3.transform.position)
						{
							flag2 = true;
						}
					}
					if (!flag2 && !instanciated)
					{
						DiversitySoundManager.CheckPosition(StartOfRound.Instance.localPlayerController);
						if (false)
						{
							return;
						}
						float num2 = Vector3.Distance(item3.transform.position, DiversitySoundManager.CheckPosition(StartOfRound.Instance.localPlayerController));
						if (num2 < 32f)
						{
							DiversitySoundManager.PlaySound(DiversitySoundManager.SoundType.LightBuzz, random: false, 0.4f, 0f, loop: true, item3.transform.position);
							nearbySounds.Add(item3.transform.position);
							instanciated = true;
						}
					}
				}
				foreach (GameObject item5 in DiversitySoundManager.Instance.current3Daudios.ToList())
				{
					if (!Object.op_Implicit((Object)(object)item5))
					{
						return;
					}
					DiversitySoundManager.CheckPosition(StartOfRound.Instance.localPlayerController);
					if (false)
					{
						return;
					}
					float num3 = Vector3.Distance(item5.transform.position, DiversitySoundManager.CheckPosition(StartOfRound.Instance.localPlayerController));
					if (num3 > 36f)
					{
						Object.Destroy((Object)(object)item5);
						DiversitySoundManager.Instance.current3Daudios.Remove(item5);
					}
				}
				soundCheckInterval = 0f;
				instanciated = false;
			}
			if (Object.op_Implicit((Object)(object)lastLight))
			{
				if (!isHaunted)
				{
					if (!unfinished)
					{
						if (timeElapsed != 1f)
						{
							timeElapsed = 1f - timeElapsed;
						}
						else
						{
							timeElapsed = 0f;
						}
						unfinished = true;
					}
					if (lastID == 0)
					{
						lastLight.intensity = Mathf.Lerp(100f, 486.8536f, timeElapsed / 1f);
					}
					else if (lastID == 1)
					{
						lastLight.intensity = Mathf.Lerp(50f, 397.9603f, timeElapsed / 1f);
					}
					timeElapsed += Time.deltaTime;
				}
				if (isHaunted)
				{
					if (unfinished)
					{
						if (timeElapsed != 1f)
						{
							timeElapsed = 1f - timeElapsed;
						}
						else
						{
							timeElapsed = 0f;
						}
						unfinished = false;
					}
					if (lastID == 0)
					{
						lastLight.intensity = Mathf.Lerp(486.8536f, 100f, timeElapsed / 1f);
					}
					else if (lastID == 1)
					{
						lastLight.intensity = Mathf.Lerp(397.9603f, 50f, timeElapsed / 1f);
					}
					timeElapsed += Time.deltaTime;
				}
				if (timeElapsed >= 1f)
				{
					timeElapsed = 1f;
				}
			}
			GrabbableObject[] itemSlots = component.ItemSlots;
			foreach (GrabbableObject val6 in itemSlots)
			{
				if ((Object)(object)val6 != (Object)null)
				{
					FlashlightRevamp component3 = ((Component)val6).gameObject.GetComponent<FlashlightRevamp>();
					if (Object.op_Implicit((Object)(object)component3))
					{
						component3.haunted = isHaunted;
					}
				}
			}
			if (sinkingFromWalker)
			{
				component.sourcesCausingSinking = 1;
				component.sinkingSpeedMultiplier = 0.1f;
			}
			else
			{
				component.sourcesCausingSinking = 0;
				component.sinkingSpeedMultiplier = 0f;
			}
			if (dressGirlHaunt)
			{
				if (component.actualClientId == localPlayerController.actualClientId || component.playerSteamId == localPlayerController.playerSteamId)
				{
					component2.hauntedIntensity = 1f;
				}
			}
			else if (component.actualClientId == localPlayerController.actualClientId || component.playerSteamId == localPlayerController.playerSteamId)
			{
				component2.hauntedIntensity = 0f;
			}
		}
	}
}
namespace Diversity.Patches
{
	[HarmonyPatch(typeof(BaboonBirdAI))]
	internal class BaboonBirdAIPatch
	{
		[HarmonyPatch(typeof(BaboonBirdAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer(BaboonBirdAI __instance, Collider other)
		{
			if (__instance.timeSinceHitting < 0.5f)
			{
				return;
			}
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, ((EnemyAI)__instance).inSpecialAnimation || __instance.doingKillAnimation, false);
			if ((Object)(object)val != (Object)null)
			{
				PlayerRevamp component = ((Component)val).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.ApplyConditions(DamageType.Bitten, 1f + (1f - (float)(val.health / 100)));
				}
			}
		}
	}
	[HarmonyPatch(typeof(BlobAI))]
	internal class BlobAIPatch
	{
		[HarmonyPatch(typeof(BlobAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer(BlobAI __instance, Collider other)
		{
			if (__instance.timeSinceHittingLocalPlayer < 0.25f || (__instance.tamedTimer > 0f && __instance.angeredTimer < 0f))
			{
				return;
			}
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, false, false);
			if ((Object)(object)val != (Object)null)
			{
				PlayerRevamp component = ((Component)val).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.ApplyConditions(DamageType.Burned, 1f + (1f - (float)(val.health / 100)));
				}
			}
		}
	}
	[HarmonyPatch(typeof(BreakerBox))]
	internal class BreakerBoxPatch : MonoBehaviour
	{
		[HarmonyPatch(typeof(BreakerBox), "Start")]
		[HarmonyPostfix]
		public static void Start(BreakerBox __instance)
		{
			BreakerBoxRevamp component = ((Component)__instance).gameObject.GetComponent<BreakerBoxRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				((Component)__instance).gameObject.AddComponent<BreakerBoxRevamp>();
				Diversity.mls.LogInfo((object)"Added DiversityBehaviour to the RoundManager.");
			}
		}

		[HarmonyPatch(typeof(BreakerBox), "SwitchBreaker")]
		[HarmonyPostfix]
		public static void SwitchBreaker(BreakerBox __instance)
		{
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			int num = 3;
			BreakerBoxRevamp component = ((Component)__instance).gameObject.GetComponent<BreakerBoxRevamp>();
			if (Object.op_Implicit((Object)(object)component))
			{
				num = component.anger;
			}
			Diversity.mls.LogInfo((object)("angerMax: " + num));
			if (!Configuration.brakenAnger.Value || !__instance.isPowerOn)
			{
				return;
			}
			FlowermanAI[] array = (FlowermanAI[])(object)Object.FindObjectsOfType(typeof(FlowermanAI));
			if (!Configuration.brakenRevamp.Value)
			{
				return;
			}
			FlowermanAI[] array2 = array;
			foreach (FlowermanAI val in array2)
			{
				BrakenRevamp component2 = ((Component)val).gameObject.GetComponent<BrakenRevamp>();
				if (!Object.op_Implicit((Object)(object)component2))
				{
					break;
				}
				if (component2.angerLevel < num)
				{
					component2.angerLevel++;
				}
				PlayerControllerB[] allPlayerScripts = __instance.roundManager.playersManager.allPlayerScripts;
				float num2 = 100f;
				PlayerControllerB val2 = null;
				PlayerControllerB[] array3 = allPlayerScripts;
				foreach (PlayerControllerB val3 in array3)
				{
					if ((Object)(object)val3 != (Object)null && Vector3.Distance(((Component)__instance).gameObject.transform.position, ((Component)val3).gameObject.transform.position) < num2)
					{
						num2 = Vector3.Distance(((Component)__instance).gameObject.transform.position, ((Component)val3).gameObject.transform.position);
						val2 = val3;
					}
				}
				if ((Object)(object)val2 != (Object)null)
				{
					Diversity.mls.LogInfo((object)("Closest player from breaker box is: " + ((Object)((Component)val2).gameObject).name));
				}
				component2.CheckAnger(component, __instance.roundManager, val2);
			}
		}
	}
	[HarmonyPatch(typeof(CentipedeAI))]
	internal class CentipedeAIPatch
	{
		[HarmonyPatch(typeof(CentipedeAI), "Start")]
		[HarmonyPrefix]
		public static void Start(CentipedeAI __instance)
		{
			if (Configuration.centipedeRevamp.Value)
			{
				CentipedeRevamp component = ((Component)__instance).gameObject.GetComponent<CentipedeRevamp>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					((Component)__instance).gameObject.AddComponent<CentipedeRevamp>();
					Diversity.mls.LogInfo((object)("Added CentipedeRevamp to: " + ((Object)((Component)__instance).gameObject).name));
				}
			}
		}

		[HarmonyPatch(typeof(CentipedeAI), "DamagePlayerOnIntervals")]
		[HarmonyPrefix]
		private static void DamagePlayerOnIntervals(CentipedeAI __instance)
		{
			if (__instance.damagePlayerInterval <= 0f && !__instance.inDroppingOffPlayerAnim && !(((EnemyAI)__instance).stunNormalizedTimer > 0f) && (StartOfRound.Instance.connectedPlayersAmount > 0 || __instance.clingingToPlayer.health > 15 || __instance.singlePlayerSecondChanceGiven) && (Object)(object)__instance.clingingToPlayer != (Object)null)
			{
				PlayerRevamp component = ((Component)__instance.clingingToPlayer).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.ApplyConditions(DamageType.Mauled, 1f + (1f - (float)(__instance.clingingToPlayer.health / 100)));
				}
			}
		}
	}
	[HarmonyPatch(typeof(CrawlerAI))]
	internal class CrawlerAIPatch
	{
		private static CrawlerRevamp crawler;

		[HarmonyPatch(typeof(CrawlerAI), "HitEnemy")]
		[HarmonyPrefix]
		public static void Slow(CrawlerAI __instance)
		{
			if (Configuration.crawlerRevamp.Value)
			{
				crawler = ((Component)__instance).GetComponent<CrawlerRevamp>();
				if (Object.op_Implicit((Object)(object)crawler) && !crawler.onCooldown)
				{
					crawler.hasBeenhit = true;
					crawler.onCooldown = true;
					crawler.previousAgentSpeed = ((EnemyAI)__instance).agent.speed;
					crawler.previousAgentAcceleration = ((EnemyAI)__instance).agent.acceleration;
					crawler.currentAgentSpeed = ((EnemyAI)__instance).agent.speed;
					crawler.currentAgentAcceleration = ((EnemyAI)__instance).agent.acceleration;
					Diversity.mls.LogInfo((object)"Crawler hit!");
				}
			}
		}

		[HarmonyPatch(typeof(CrawlerAI), "Start")]
		[HarmonyPrefix]
		public static void Start(CrawlerAI __instance)
		{
			if (Configuration.crawlerRevamp.Value)
			{
				crawler = ((Component)__instance).gameObject.GetComponent<CrawlerRevamp>();
				if (!Object.op_Implicit((Object)(object)crawler))
				{
					((Component)__instance).gameObject.AddComponent<CrawlerRevamp>();
					Diversity.mls.LogInfo((object)("Added CrawlerRevamp to: " + ((Object)((Component)__instance).gameObject).name));
				}
			}
		}

		[HarmonyPatch(typeof(CrawlerAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer(CrawlerAI __instance, Collider other)
		{
			if (__instance.timeSinceHittingPlayer < 0.65f)
			{
				return;
			}
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, false, false);
			if ((Object)(object)val != (Object)null)
			{
				PlayerRevamp component = ((Component)val).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.ApplyConditions(DamageType.Bitten, 1f + (1f - (float)(val.health / 100)));
				}
			}
		}
	}
	[HarmonyPatch(typeof(DressGirlAI))]
	internal class DressGirlAIPatch
	{
		[HarmonyPatch(typeof(DressGirlAI), "Start")]
		[HarmonyPrefix]
		private static void Start(DressGirlAI __instance)
		{
			if (Configuration.dressGirlRevamp.Value)
			{
				DressGirlRevamp component = ((Component)__instance).gameObject.GetComponent<DressGirlRevamp>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					((Component)__instance).gameObject.AddComponent<DressGirlRevamp>();
					Diversity.mls.LogInfo((object)("Added DressGirlRevamp to: " + ((Object)((Component)__instance).gameObject).name));
				}
			}
		}

		[HarmonyPatch(typeof(DressGirlAI), "Update")]
		[HarmonyPostfix]
		private static void Update(DressGirlAI __instance)
		{
			if (Configuration.dressGirlRevamp.Value)
			{
				DressGirlRevamp component = ((Component)__instance).gameObject.GetComponent<DressGirlRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.timeElapsed += Time.deltaTime;
					component.TryWalkieTalkie(__instance.hauntingPlayer);
				}
			}
		}

		[HarmonyPatch(typeof(DressGirlAI), "BeginChasing")]
		[HarmonyPostfix]
		private static void BeginChasing(DressGirlAI __instance)
		{
			if (Configuration.dressGirlRevamp.Value && Configuration.dressGirlIsolation.Value && !((Object)(object)__instance.hauntingPlayer == (Object)null))
			{
				PlayerRevamp component = ((Component)__instance.hauntingPlayer).GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.dressGirlHaunt = true;
				}
			}
		}

		[HarmonyPatch(typeof(DressGirlAI), "StopChasing")]
		[HarmonyPostfix]
		private static void StopChasing(DressGirlAI __instance)
		{
			if (!Configuration.dressGirlRevamp.Value || !Configuration.dressGirlIsolation.Value || (Object)(object)__instance.hauntingPlayer == (Object)null)
			{
				return;
			}
			PlayerRevamp component = ((Component)__instance.hauntingPlayer).GetComponent<PlayerRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			component.dressGirlHaunt = false;
			DiversitySoundManager.StopSoundBypass();
			if (DiversitySoundManager.Instance.currentGirlAudios.Count <= 0)
			{
				return;
			}
			foreach (GameObject item in DiversitySoundManager.Instance.currentGirlAudios.ToList())
			{
				item.GetComponent<AudioSource>().Stop();
				DiversitySoundManager.DeleteAudio(item);
				DiversitySoundManager.Instance.currentGirlAudios.Remove(item);
			}
		}
	}
	[HarmonyPatch(typeof(FlashlightItem))]
	public class FlashlightPatch : MonoBehaviour
	{
		private static bool wasHaunted;

		private static float timeElapsed;

		[HarmonyPatch(typeof(FlashlightItem), "Update")]
		[HarmonyPostfix]
		private static void Update(FlashlightItem __instance)
		{
			if (!Configuration.brakenRevamp.Value)
			{
				return;
			}
			FlashlightRevamp component = ((Component)__instance).gameObject.GetComponent<FlashlightRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			if (component.haunted)
			{
				if (!wasHaunted)
				{
					wasHaunted = true;
				}
				__instance.flashlightBulb.intensity = component.currentIntensity;
				timeElapsed = 0f;
			}
			else
			{
				timeElapsed += Time.deltaTime;
				if (timeElapsed >= 1f)
				{
					wasHaunted = false;
				}
			}
		}

		[HarmonyPatch(typeof(FlashlightItem), "Start")]
		[HarmonyPrefix]
		public static void Start(FlashlightItem __instance)
		{
			if (Configuration.brakenRevamp.Value)
			{
				FlashlightRevamp component = ((Component)__instance).gameObject.GetComponent<FlashlightRevamp>();
				Rigidbody component2 = ((Component)__instance).gameObject.GetComponent<Rigidbody>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					((Component)__instance).gameObject.AddComponent<FlashlightRevamp>();
					Diversity.mls.LogInfo((object)("Added FlashlightRevamp to: " + ((Object)((Component)__instance).gameObject).name));
				}
				if (!Object.op_Implicit((Object)(object)component2))
				{
					Rigidbody val = ((Component)__instance).gameObject.AddComponent<Rigidbody>();
					val.isKinematic = true;
					Diversity.mls.LogInfo((object)("Added Rigidbody to: " + ((Object)((Component)__instance).gameObject).name));
				}
			}
		}
	}
	[HarmonyPatch(typeof(FlowermanAI))]
	internal class FlowermanAIPatch
	{
		[HarmonyPatch(typeof(FlowermanAI), "Start")]
		[HarmonyPrefix]
		public static void Start(FlowermanAI __instance)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			if (Configuration.brakenRevamp.Value)
			{
				BrakenRevamp component = ((Component)__instance).gameObject.GetComponent<BrakenRevamp>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					((Component)__instance).gameObject.AddComponent<BrakenRevamp>();
					Diversity.mls.LogInfo((object)("Added BrakenRevamp to: " + ((Object)((Component)__instance).gameObject).name));
				}
				GameObject val = new GameObject("CreatureSpeech");
				AudioSource val2 = val.AddComponent<AudioSource>();
				val2.loop = false;
				((Behaviour)val2).enabled = true;
				val2.playOnAwake = false;
				val2.volume = 1f;
				val2.spatialBlend = 0f;
				val2.clip = Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/bracken/you're next.mp3");
				val.transform.SetParent(((Component)__instance).gameObject.transform);
				Diversity.mls.LogInfo((object)("Added CreatureSpeech to: " + ((Object)((Component)__instance).gameObject).name));
			}
		}

		[HarmonyPatch(typeof(FlowermanAI), "killAnimation")]
		[HarmonyPostfix]
		private static void killAnimation(FlowermanAI __instance)
		{
			if (!Configuration.brakenRevamp.Value || !((Object)(object)((EnemyAI)__instance).inSpecialAnimationWithPlayer != (Object)null))
			{
				return;
			}
			Transform val = ((Component)__instance).gameObject.transform.Find("CreatureSpeech");
			if (Object.op_Implicit((Object)(object)val))
			{
				AudioSource component = ((Component)val).GetComponent<AudioSource>();
				BrakenRevamp component2 = ((Component)__instance).gameObject.GetComponent<BrakenRevamp>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					component2.TransmitWalkie(component.clip);
				}
			}
		}

		[HarmonyPatch(typeof(FlowermanAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer(FlowermanAI __instance, Collider other)
		{
			if (!Configuration.brakenSpace.Value)
			{
				return;
			}
			BrakenRevamp component = ((Component)__instance).gameObject.GetComponent<BrakenRevamp>();
			StartOfRoundRevamp component2 = ((Component)StartOfRound.Instance).gameObject.GetComponent<StartOfRoundRevamp>();
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, __instance.inKillAnimation || __instance.startingKillAnimationLocalClient || __instance.carryingPlayerBody, false);
			if ((Object)(object)val != (Object)null && Object.op_Implicit((Object)(object)component) && !component.kidnapped)
			{
				component.kidnapped = true;
				if (Object.op_Implicit((Object)(object)component2))
				{
					component2.Kidnap(val);
					StartOfRound.Instance.allowLocalPlayerDeath = false;
					((Component)((Component)val).gameObject.transform.Find("Misc").Find("MapDot")).gameObject.SetActive(false);
					component.ResetAnimation(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(HoarderBugAI))]
	internal class HoarderBugAIPatch
	{
		[HarmonyPatch(typeof(HoarderBugAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer(HoarderBugAI __instance, Collider other)
		{
			if (!__instance.inChase || __instance.timeSinceHittingPlayer < 0.5f)
			{
				return;
			}
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, false, false);
			if ((Object)(object)val != (Object)null)
			{
				PlayerRevamp component = ((Component)val).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.ApplyConditions(DamageType.Mauled, 1f + (1f - (float)(val.health / 100)));
				}
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	public class HUDPatch
	{
		public static TextMeshProUGUI tipText;

		public static Image holderBar;

		public static Image clickBar;

		private static readonly string text = "Free from head : [E]";

		private static readonly Color color = Color32.op_Implicit(new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue));

		[HarmonyPatch(typeof(HUDManager), "Start")]
		[HarmonyPostfix]
		private static void Start(ref HUDManager __instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InteractText");
			val.AddComponent<RectTransform>();
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
			((Transform)rectTransform).SetParent(((TMP_Text)__instance.signalTranslatorText).transform, false);
			Rect rect = rectTransform.rect;
			rectTransform.anchoredPosition = new Vector2((0f - ((Rect)(ref rect)).width) / 4f + 5f, -40f);
			GameObject val3 = new GameObject("InteractBarHolder");
			val3.AddComponent<RectTransform>();
			Image val4 = val3.AddComponent<Image>();
			val4.sprite = Content.MainAssets.LoadAsset<Sprite>("Assets/custom/diversity/hud/holder.png");
			RectTransform component = ((Component)val4).GetComponent<RectTransform>();
			((Transform)component).SetParent(((TMP_Text)__instance.signalTranslatorText).transform, false);
			component.sizeDelta = new Vector2(133.33333f, 20f);
			rect = rectTransform.rect;
			component.anchoredPosition = new Vector2((0f - ((Rect)(ref rect)).width) / 4f + 5f, -70f);
			((Behaviour)val4).enabled = false;
			holderBar = val4;
			GameObject val5 = new GameObject("InteractBarHolder");
			val5.AddComponent<RectTransform>();
			Image val6 = val5.AddComponent<Image>();
			val6.sprite = Content.MainAssets.LoadAsset<Sprite>("Assets/custom/diversity/hud/bar.png");
			RectTransform component2 = ((Component)val6).GetComponent<RectTransform>();
			((Transform)component2).SetParent(((TMP_Text)__instance.signalTranslatorText).transform, false);
			component2.sizeDelta = new Vector2(133.33333f, 20f);
			rect = rectTransform.rect;
			component2.anchoredPosition = new Vector2((0f - ((Rect)(ref rect)).width) / 4f + 5f, -70f);
			((Behaviour)val6).enabled = false;
			clickBar = val6;
			((TMP_Text)val2).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val2).font = ((TMP_Text)__instance.controlTipLines[0]).font;
			((TMP_Text)val2).fontSize = 16f;
			((TMP_Text)val2).text = text;
			((Graphic)val2).color = color;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
			((Behaviour)val2).enabled = false;
			tipText = val2;
			HUDManagerRevamp component3 = ((Component)__instance).gameObject.GetComponent<HUDManagerRevamp>();
			if (!Object.op_Implicit((Object)(object)component3))
			{
				((Component)__instance).gameObject.AddComponent<HUDManagerRevamp>();
				Diversity.mls.LogInfo((object)("Added HUDManagerRevamp to: " + ((Object)((Component)__instance).gameObject).name));
			}
		}

		[HarmonyPatch(typeof(HUDManager), "UnderwaterScreenFilters")]
		[HarmonyPostfix]
		private static void UnderwaterScreenFilters(HUDManager __instance)
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if (!Object.op_Implicit((Object)(object)localPlayerController))
			{
				return;
			}
			PlayerRevamp component = ((Component)localPlayerController).gameObject.GetComponent<PlayerRevamp>();
			if (Object.op_Implicit((Object)(object)component))
			{
				if (component.filter > 0f)
				{
					((Behaviour)__instance.audioListenerLowPass).enabled = true;
					__instance.audioListenerLowPass.cutoffFrequency = 20000f * (1f - component.filter);
				}
				else
				{
					((Behaviour)__instance.audioListenerLowPass).enabled = false;
					__instance.audioListenerLowPass.cutoffFrequency = 20000f * (1f - component.filter);
				}
			}
		}
	}
	[HarmonyPatch(typeof(LungProp))]
	internal class LungPropPatch
	{
		[HarmonyPatch(typeof(LungProp), "Start")]
		[HarmonyPrefix]
		private static void Start(LungProp __instance)
		{
			if (Configuration.brakenRevamp.Value)
			{
				LungPropRevamp component = ((Component)__instance).gameObject.GetComponent<LungPropRevamp>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					((Component)__instance).gameObject.AddComponent<LungPropRevamp>();
					Diversity.mls.LogInfo((object)("Added LungPropRevamp to: " + ((Object)((Component)__instance).gameObject).name));
				}
			}
		}

		[HarmonyPatch(typeof(LungProp), "DisconnectFromMachinery")]
		[HarmonyPostfix]
		private static void DisconnectFromMachinery(LungProp __instance)
		{
			if (Configuration.brakenRevamp.Value && Configuration.apparatusAnger.Value)
			{
				LungPropRevamp component = ((Component)__instance).gameObject.GetComponent<LungPropRevamp>();
				if (Object.op_Implicit((Object)(object)component) && (Object)(object)((GrabbableObject)__instance).playerHeldBy != (Object)null)
				{
					component.AngerBracken(__instance.roundManager, ((GrabbableObject)__instance).playerHeldBy);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ManualCameraRenderer))]
	internal class ManualCameraRendererPatch
	{
		[HarmonyPatch(typeof(ManualCameraRenderer), "MapCameraFocusOnPosition")]
		[HarmonyPostfix]
		private static void MapCameraFocusOnPosition(ManualCameraRenderer __instance)
		{
			if (!Configuration.brakenSpace.Value || !Object.op_Implicit((Object)(object)__instance.targetedPlayer))
			{
				return;
			}
			PlayerRevamp component = ((Component)__instance.targetedPlayer).gameObject.GetComponent<PlayerRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			if (component.kidnapped)
			{
				if (__instance.isScreenOn)
				{
					((Behaviour)StartOfRound.Instance.mapScreenPlayerName).enabled = false;
					__instance.mapCamera.cullingMask = LayerMask.GetMask(new string[1] { "MapRadar" });
					Transform val = ((TMP_Text)StartOfRound.Instance.mapScreenPlayerName).transform.parent.Find("ErrorText");
					if (Object.op_Implicit((Object)(object)val))
					{
						((Component)val).gameObject.SetActive(true);
					}
				}
			}
			else if (__instance.isScreenOn)
			{
				((Behaviour)StartOfRound.Instance.mapScreenPlayerName).enabled = true;
				__instance.mapCamera.cullingMask = 16640;
				Transform val2 = ((TMP_Text)StartOfRound.Instance.mapScreenPlayerName).transform.parent.Find("ErrorText");
				if (Object.op_Implicit((Object)(object)val2))
				{
					((Component)val2).gameObject.SetActive(false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	public class PlayerControllerBPatch
	{
		public static Transform InteractorSource;

		private static float InteractRange = Configuration.interactRange.Value;

		public static PlayerControllerB player;

		private static CentipedeRevamp revamp;

		[HarmonyPatch(typeof(PlayerControllerB), "Start")]
		[HarmonyPrefix]
		public static void Start(PlayerControllerB __instance)
		{
			PlayerRevamp component = ((Component)__instance).gameObject.GetComponent<PlayerRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				((Component)__instance).gameObject.AddComponent<PlayerRevamp>();
				Diversity.mls.LogInfo((object)("Added PlayerRevamp to: " + ((Object)((Component)__instance).gameObject).name));
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "CheckConditionsForSinkingInQuicksand")]
		[HarmonyPrefix]
		private static bool CheckConditionsForSinkingInQuicksand(PlayerControllerB __instance, ref bool __result)
		{
			PlayerRevamp component = ((Component)__instance).gameObject.GetComponent<PlayerRevamp>();
			if (component.sinkingFromWalker)
			{
				__result = true;
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		private static void Update(PlayerControllerB __instance)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: 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_03ac: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance.currentlyHeldObject != (Object)null && Object.op_Implicit((Object)(object)((Component)__instance.currentlyHeldObject).GetComponent<FlashlightItem>()) && Object.op_Implicit((Object)(object)((Component)__instance).gameObject.GetComponent<PlayerRevamp>()))
			{
				((Component)__instance).gameObject.GetComponent<PlayerRevamp>().lastID = ((Component)__instance.currentlyHeldObject).GetComponent<FlashlightItem>().flashlightTypeID;
			}
			if ((Object)(object)__instance == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				MovementActions movement = __instance.playerActions.Movement;
				if (((MovementActions)(ref movement)).Interact.WasPressedThisFrame())
				{
					InteractorSource = ((Component)__instance.gameplayCamera).transform;
					Ray val = default(Ray);
					((Ray)(ref val))..ctor(InteractorSource.position, InteractorSource.forward);
					RaycastHit val2 = default(RaycastHit);
					if (Physics.Raycast(val, ref val2, InteractRange, LayerMask.GetMask(new string[4] { "Enemies", "Room", "Terrain", "Railing" })))
					{
						Diversity.mls.LogInfo((object)("Interactor interacted with: " + ((Object)((Component)((RaycastHit)(ref val2)).transform).gameObject).name));
						if (((Object)((Component)((RaycastHit)(ref val2)).transform).gameObject).name == "brackendoor")
						{
							BrackenDoor component = ((Component)((RaycastHit)(ref val2)).transform).gameObject.GetComponent<BrackenDoor>();
							if (!Object.op_Implicit((Object)(object)component))
							{
								return;
							}
							component.CheckClicks(__instance);
						}
						else if (Configuration.centipedeRevamp.Value)
						{
							try
							{
								revamp = ((Component)((Component)((RaycastHit)(ref val2)).collider).transform.parent).gameObject.GetComponent<CentipedeRevamp>();
							}
							catch (Exception)
							{
							}
							if (!Object.op_Implicit((Object)(object)revamp))
							{
								return;
							}
							Diversity.mls.LogInfo((object)("Centipede clinging: " + revamp.clinging));
							Diversity.mls.LogInfo((object)("Amount of click done: " + revamp.clicks));
							if (revamp.clinging)
							{
								revamp.clicks++;
								float value = Random.value;
								if (value < (float)(Configuration.hurtChance.Value / 100))
								{
									__instance.DamagePlayer(5, true, true, (CauseOfDeath)6, 0, false, default(Vector3));
								}
							}
						}
					}
				}
			}
			if ((Object)(object)__instance == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				InteractorSource = ((Component)__instance.gameplayCamera).transform;
				Ray val3 = default(Ray);
				((Ray)(ref val3))..ctor(InteractorSource.position, InteractorSource.forward);
				RaycastHit val4 = default(RaycastHit);
				if (Physics.Raycast(val3, ref val4, InteractRange, LayerMask.GetMask(new string[4] { "Enemies", "Room", "Terrain", "Railing" })))
				{
					if (((Object)((Component)((RaycastHit)(ref val4)).transform).gameObject).name == "brackendoor")
					{
						BrackenDoor component2 = ((Component)((RaycastHit)(ref val4)).transform).gameObject.GetComponent<BrackenDoor>();
						if (!Object.op_Implicit((Object)(object)component2))
						{
							return;
						}
						((Behaviour)HUDPatch.tipText).enabled = true;
						((TMP_Text)HUDPatch.tipText).text = "Break out! : [E]";
						((Behaviour)HUDPatch.holderBar).enabled = true;
						((Behaviour)HUDPatch.clickBar).enabled = true;
						((Graphic)HUDPatch.clickBar).rectTransform.sizeDelta = new Vector2(8f * (float)component2.clicks / 1.5f, 20f);
					}
					else
					{
						try
						{
							revamp = ((Component)((Component)((RaycastHit)(ref val4)).collider).transform.parent).gameObject.GetComponent<CentipedeRevamp>();
						}
						catch (Exception)
						{
						}
						if (!Object.op_Implicit((Object)(object)revamp))
						{
							return;
						}
						if (revamp.clinging)
						{
							((Behaviour)HUDPatch.tipText).enabled = true;
							((TMP_Text)HUDPatch.tipText).text = "Free from head : [E]";
							((Behaviour)HUDPatch.holderBar).enabled = true;
							((Behaviour)HUDPatch.clickBar).enabled = true;
							((Graphic)HUDPatch.clickBar).rectTransform.sizeDelta = new Vector2((float)(200 / Configuration.clickAmount.Value * revamp.clicks) / 1.5f, 20f);
						}
					}
				}
				else
				{
					((Behaviour)HUDPatch.tipText).enabled = false;
					((Behaviour)HUDPatch.holderBar).enabled = false;
					((Behaviour)HUDPatch.clickBar).enabled = false;
				}
			}
			if (Configuration.playerConditions.Value)
			{
				PlayerRevamp component3 = ((Component)__instance).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component3))
				{
					component3.CheckConditions(__instance);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
		private static void LateUpdate(PlayerControllerB __instance)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			PlayerRevamp component = ((Component)__instance).gameObject.GetComponent<PlayerRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			if (((Component)__instance).gameObject.transform.position.y > -350f && !__instance.isPlayerDead)
			{
				component.kidnapped = false;
			}
			if (component.kidnapped)
			{
				__instance.sprintMeter = 1f;
				((Component)__instance.mapRadarDotAnimator).gameObject.SetActive(false);
				return;
			}
			((Component)__instance.mapRadarDotAnimator).gameObject.SetActive(true);
			bool flag = false;
			bool flag2 = false;
			using (List<Condition>.Enumerator enumerator = component.conditions.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					switch (enumerator.Current)
					{
					case Condition.FracturedLeg:
						flag = true;
						break;
					case Condition.BrokenLeg:
						flag2 = true;
						break;
					}
				}
			}
			float num = 1f;
			if (__instance.drunkness > 0.02f)
			{
				num *= Mathf.Abs(StartOfRound.Instance.drunknessSpeedEffect.Evaluate(__instance.drunkness) - 1.25f);
			}
			if (flag2)
			{
				if (__instance.isSprinting)
				{
					__instance.sprintMeter = Mathf.Clamp(__instance.sprintMeter - Time.deltaTime / (__instance.sprintTime / 1.5f) * __instance.carryWeight * num, 0f, 1f);
				}
				else if (__instance.isMovementHindered > 0)
				{
					if (__instance.isWalking)
					{
						__instance.sprintMeter = Mathf.Clamp(__instance.sprintMeter - Time.deltaTime / (__instance.sprintTime / 1.5f) * num * 0.5f, 0f, 1f);
					}
				}
				else if (!__instance.isWalking)
				{
					__instance.sprintMeter = Mathf.Clamp(__instance.sprintMeter + Time.deltaTime / (__instance.sprintTime / 1.5f + 4f) * num, 0f, 1f);
				}
				else
				{
					__instance.sprintMeter = Mathf.Clamp(__instance.sprintMeter + Time.deltaTime / (__instance.sprintTime / 1.5f + 9f) * num, 0f, 1f);
				}
			}
			else
			{
				if (!flag)
				{
					return;
				}
				if (__instance.isSprinting)
				{
					__instance.sprintMeter = Mathf.Clamp(__instance.sprintMeter - Time.deltaTime / (__instance.sprintTime / 1.2f) * __instance.carryWeight * num, 0f, 1f);
				}
				else if (__instance.isMovementHindered > 0)
				{
					if (__instance.isWalking)
					{
						__instance.sprintMeter = Mathf.Clamp(__instance.sprintMeter - Time.deltaTime / (__instance.sprintTime / 1.2f) * num * 0.5f, 0f, 1f);
					}
				}
				else if (!__instance.isWalking)
				{
					__instance.sprintMeter = Mathf.Clamp(__instance.sprintMeter + Time.deltaTime / (__instance.sprintTime / 1.2f + 4f) * num, 0f, 1f);
				}
				else
				{
					__instance.sprintMeter = Mathf.Clamp(__instance.sprintMeter + Time.deltaTime / (__instance.sprintTime / 1.2f + 9f) * num, 0f, 1f);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayer")]
		[HarmonyPrefix]
		private static void DamagePlayer(PlayerControllerB __instance, int damageNumber, bool hasDamageSFX = true, bool callRPC = true, CauseOfDeath causeOfDeath = 0, int deathAnimation = 0, bool fallDamage = false, Vector3 force = default(Vector3))
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Invalid comparison between Unknown and I4
			if (!Configuration.playerConditions.Value)
			{
				return;
			}
			PlayerRevamp component = ((Component)__instance).gameObject.GetComponent<PlayerRevamp>();
			if (Object.op_Implicit((Object)(object)component))
			{
				if ((int)causeOfDeath == 2)
				{
					component.ApplyConditions(DamageType.Falling, 1f + (1f - (float)(__instance.health / 100)));
				}
				else if ((int)causeOfDeath == 7)
				{
					component.ApplyConditions(DamageType.GunShotted, 1f + (1f - (float)(__instance.health / 100)));
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
		[HarmonyPrefix]
		private static void KillPlayer(PlayerControllerB __instance)
		{
			PlayerRevamp component = ((Component)__instance).gameObject.GetComponent<PlayerRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			if (component.kidnapped)
			{
				StartOfRoundRevamp component2 = ((Component)StartOfRound.Instance).gameObject.GetComponent<StartOfRoundRevamp>();
				if (!Object.op_Implicit((Object)(object)component2))
				{
					return;
				}
				foreach (GameObject currentEffect in component2.currentEffects)
				{
					currentEffect.SetActive(true);
				}
			}
			if (Configuration.playerConditions.Value)
			{
				component.conditions.Clear();
				HUDManagerRevamp component3 = ((Component)HUDManager.Instance).gameObject.GetComponent<HUDManagerRevamp>();
				if (Object.op_Implicit((Object)(object)component3) && ((Object)(object)__instance == (Object)(object)StartOfRound.Instance.localPlayerController || __instance.actualClientId == StartOfRound.Instance.localPlayerController.actualClientId))
				{
					component3.blindnessIntensity = 0f;
					component3.concussedIntensity = 0f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(PufferAI))]
	internal class PufferAIPatch
	{
		[HarmonyPatch(typeof(PufferAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer(PufferAI __instance, Collider other)
		{
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, false, false);
			if ((Object)(object)val != (Object)null && __instance.timeSinceHittingPlayer > 1f)
			{
				PlayerRevamp component = ((Component)val).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.ApplyConditions(DamageType.Bitten, 1f + (1f - (float)(val.health / 100)));
				}
			}
		}

		[HarmonyPatch(typeof(PufferAI), "Start")]
		[HarmonyPrefix]
		private static void Start(PufferAI __instance)
		{
			GameObject smokePrefab = __instance.smokePrefab;
			SphereCollider component = smokePrefab.GetComponent<SphereCollider>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				SphereCollider val = smokePrefab.AddComponent<SphereCollider>();
				((Collider)val).isTrigger = true;
				val.radius = 14f;
				Diversity.mls.LogInfo((object)("Added SphereCollider to: " + ((Object)smokePrefab).name));
			}
			Rigidbody component2 = smokePrefab.GetComponent<Rigidbody>();
			if (!Object.op_Implicit((Object)(object)component2))
			{
				Rigidbody val2 = smokePrefab.AddComponent<Rigidbody>();
				val2.isKinematic = true;
				Diversity.mls.LogInfo((object)("Added Rigidbody to: " + ((Object)smokePrefab).name));
			}
			PufferSmokeRevamp component3 = smokePrefab.GetComponent<PufferSmokeRevamp>();
			if (!Object.op_Implicit((Object)(object)component3))
			{
				PufferSmokeRevamp pufferSmokeRevamp = smokePrefab.AddComponent<PufferSmokeRevamp>();
				Diversity.mls.LogInfo((object)("Added PufferSmokeRevamp to: " + ((Object)smokePrefab).name));
			}
		}
	}
	[HarmonyPatch(typeof(RadarBoosterItem), "Start")]
	internal class RadarBoosterItemPatch
	{
		[HarmonyPatch(typeof(RadarBoosterItem), "Start")]
		[HarmonyPostfix]
		public static void Start(RadarBoosterItem __instance)
		{
			RadarBoosterItemRevamp component = ((Component)__instance).gameObject.GetComponent<RadarBoosterItemRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				((Component)__instance).gameObject.AddComponent<RadarBoosterItemRevamp>();
			}
			StartOfRoundRevamp.Instance.radarBoosters.Add(__instance);
		}
	}
	[HarmonyPatch(typeof(RedLocustBees))]
	internal class RedLocustBeesPatch
	{
		[HarmonyPatch(typeof(RedLocustBees), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer(RedLocustBees __instance, Collider other)
		{
			if (__instance.timeSinceHittingPlayer < 0.4f)
			{
				return;
			}
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, false, false);
			if ((Object)(object)val != (Object)null && (val.health > 10 || !val.criticallyInjured))
			{
				PlayerRevamp component = ((Component)val).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.ApplyConditions(DamageType.Electrified, 1f + (1f - (float)(val.health / 100)));
				}
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManagerPatch : MonoBehaviour
	{
		[HarmonyPatch(typeof(RoundManager), "FinishGeneratingLevel")]
		[HarmonyPostfix]
		public static void FinishGeneratingLevel(RoundManager __instance)
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Expected O, but got Unknown
			Vector3 startPos = default(Vector3);
			((Vector3)(ref startPos))..ctor(300f, -400f, 0f);
			GameObject test = Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/test.prefab");
			GameObject start = Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/start.prefab");
			GameObject end = Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/end.prefab");
			List<GameObject> list = new List<GameObject>();
			list.Add(Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/hall1.prefab"));
			list.Add(Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/hall2.prefab"));
			list.Add(Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/hall3.prefab"));
			list.Add(Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/hall4.prefab"));
			list.Add(Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/hall5.prefab"));
			list.Add(Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/hall6.prefab"));
			list.Add(Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/hall7.prefab"));
			list.Add(Content.MainAssets.LoadAsset<GameObject>("Assets/custom/diversity/bracken/rooms/prefabs/hall8.prefab"));
			StartOfRoundRevamp component = ((Component)StartOfRound.Instance).gameObject.GetComponent<StartOfRoundRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			component.GenerateRoom(StartOfRound.Instance.randomMapSeed, startPos, test, list, start, end, isTest: false);
			Light[] array = Object.FindObjectsOfType<Light>();
			Light[] array2 = array;
			foreach (Light val in array2)
			{
				if (Object.op_Implicit((Object)(object)((Component)val).transform.parent) && (((Object)((Component)val).transform.parent).name.StartsWith("HangingLight") || ((Object)((Component)val).transform.parent).name.StartsWith("WallFixtureLight") || ((Object)((Component)val).transform.parent).name.StartsWith("MansionWallLamp") || ((Object)((Component)val).transform.parent).name.StartsWith("Chandelier")))
				{
					GameObject gameObject = ((Component)val).gameObject;
					StartOfRoundRevamp.Instance.brackenLights.Add(gameObject);
				}
			}
			GameObject val2 = new GameObject("BrakenScreamAudio");
			AudioSource val3 = val2.AddComponent<AudioSource>();
			val3.loop = false;
			((Behaviour)val3).enabled = false;
			val3.playOnAwake = true;
			val3.volume = 1f;
			val3.spatialBlend = 0f;
			val3.clip = Content.MainAssets.LoadAsset<AudioClip>("Assets/custom/diversity/bracken/brakenScream.mp3");
			AnimationCurve val4 = new AnimationCurve();
			val4.AddKey(0f, 1f);
			val4.AddKey(1f, 1f);
			val3.SetCustomCurve((AudioSourceCurveType)0, val4);
			Object.Instantiate<GameObject>(val2);
			Diversity.mls.LogInfo((object)"Bracken scream audio created.");
		}
	}
	[HarmonyPatch(typeof(SandSpiderAI))]
	internal class SandSpiderAIPatch
	{
		private static SpiderRevamp spider;

		[HarmonyPatch(typeof(SandSpiderAI), "HitEnemy")]
		[HarmonyPrefix]
		public static void Slow(SandSpiderAI __instance)
		{
			spider = ((Component)__instance).GetComponent<SpiderRevamp>();
			if (Object.op_Implicit((Object)(object)spider) && !spider.onCooldown)
			{
				spider.hasBeenhit = true;
				spider.onCooldown = true;
				spider.previousAgentSpeed = ((EnemyAI)__instance).agent.speed;
				spider.previousSpiderSpeed = __instance.spiderSpeed;
				spider.currentAgentSpeed = ((EnemyAI)__instance).agent.speed;
				spider.currentSpiderSpeed = __instance.spiderSpeed;
				Diversity.mls.LogInfo((object)"Spider hit!");
			}
		}

		[HarmonyPatch(typeof(SandSpiderAI), "Start")]
		[HarmonyPrefix]
		public static void Start(SandSpiderAI __instance)
		{
			if (Configuration.spiderRevamp.Value)
			{
				spider = ((Component)__instance).gameObject.GetComponent<SpiderRevamp>();
				if (!Object.op_Implicit((Object)(object)spider))
				{
					((Component)__instance).gameObject.AddComponent<SpiderRevamp>();
					Diversity.mls.LogInfo((object)("Added SpiderRevamp to: " + ((Object)((Component)__instance).gameObject).name));
				}
			}
		}

		[HarmonyPatch(typeof(SandSpiderAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer(SandSpiderAI __instance, Collider other)
		{
			if (((EnemyAI)__instance).isEnemyDead || __instance.onWall)
			{
				return;
			}
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, __instance.spoolingPlayerBody, false);
			if ((Object)(object)val != (Object)null && __instance.timeSinceHittingPlayer > 1f)
			{
				PlayerRevamp component = ((Component)val).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.ApplyConditions(DamageType.Mauled, 1f + (1f - (float)(val.health / 100)));
				}
			}
		}
	}
	[HarmonyPatch(typeof(ShipTeleporter))]
	internal class ShipTeleporterPatch
	{
		[HarmonyPatch(typeof(ShipTeleporter), "Awake")]
		[HarmonyPrefix]
		private static void Awake(ShipTeleporter __instance)
		{
			ShipTeleporterRevamp component = ((Component)__instance).gameObject.GetComponent<ShipTeleporterRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				((Component)__instance).gameObject.AddComponent<ShipTeleporterRevamp>();
			}
		}
	}
	[HarmonyPatch(typeof(SoundManager))]
	internal class SoundManagerPatch
	{
		[HarmonyPatch(typeof(SoundManager), "SetPlayerVoiceFilters")]
		[HarmonyPostfix]
		private static void SetPlayerVoiceFilters(SoundManager __instance)
		{
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
			{
				if (!StartOfRound.Instance.allPlayerScripts[i].isPlayerDead && (Object)(object)StartOfRound.Instance.allPlayerScripts[i] != (Object)(object)StartOfRound.Instance.localPlayerController)
				{
					PlayerRevamp component = ((Component)StartOfRound.Instance.localPlayerController).gameObject.GetComponent<PlayerRevamp>();
					if (!Object.op_Implicit((Object)(object)component))
					{
						break;
					}
					if (component.dressGirlHaunt)
					{
						__instance.diageticMixer.SetFloat($"PlayerVolume{i}", -80f);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(SpringManAI))]
	internal class SpringManAIPatch
	{
		[HarmonyPatch(typeof(SpringManAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer(SpringManAI __instance, Collider other)
		{
			if (__instance.stoppingMovement || ((EnemyAI)__instance).currentBehaviourStateIndex != 1 || __instance.timeSinceHittingPlayer >= 0f)
			{
				return;
			}
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, false, false);
			if ((Object)(object)val != (Object)null)
			{
				PlayerRevamp component = ((Component)val).gameObject.GetComponent<PlayerRevamp>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.ApplyConditions(DamageType.Concussed, 1f + (1f - (float)(val.health / 100)));
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPrefix]
		private static void Start(StartOfRound __instance)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			StartOfRoundRevamp component = ((Component)__instance).gameObject.GetComponent<StartOfRoundRevamp>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				((Component)__instance).gameObject.AddComponent<StartOfRoundRevamp>();
				Diversity.mls.LogInfo((object)("Added StartOfRoundRevamp to: " + ((Object)((Component)__instance).gameObject).name));
			}
			if (Configuration.brakenSpace.Value)
			{
				GameObject gameObject = ((Component)((Component)__instance.mapScreenPlayerName).gameObject.transform.parent).gameObject;
				GameObject val = new GameObject("ErrorText");
				val.layer = 14;
				val.AddComponent<RectTransform>();
				val.AddComponent<CanvasRenderer>();
				TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val2).font = ((TMP_Text)HUDManager.Instance.controlTipLines[0]).font;
				((TMP_Text)val2).fontSize = 17f;
				((TMP_Text)val2).alignment = (TextAlignmentOptions)514;
				((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
				((TMP_Text)val2).text = "THEY ARE PAYING\nTHE PRICE";
				((Graphic)val2).color = Color.red;
				((Behaviour)val2).enabled = true;
				val.transform.SetParent(gameObject.transform);
				val.transform.localPosition = Vector3.zero;
				val.transform.localScale = new Vector3(2f, 2f, 2f);
				val.transform.localRotation = Quaternion.identity;
				val.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "EndOfGame")]
		[HarmonyPrefix]
		private static void EndOfGame(StartOfRound __instance)
		{
			PlayerControllerB[] allPlayerScripts = __instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if ((Object)(object)val != (Object)null)
				{
					PlayerRevamp component = ((Component)val).gameObject.GetComponent<PlayerRevamp>();
					if (!Object.op_Implicit((Object)(object)component))
					{
						return;
					}
					component.conditions.Clear();
					component.updated = false;
					val.playerBodyAnimator.SetBool("Limp", false);
					val.jumpForce = 13f;
					val.bleedingHeavily = false;
					val.isMovementHindered = 0;
					val.hinderedMultiplier = 1f;
					component.nearbySounds.Clear();
					DiversitySoundManager.Instance.current3Daudios.Clear();
					StartOfRoundRevamp.Instance.brackenLights.Clear();
					StartOfRoundRevamp.Instance.affectedLights.Clear();
					StartOfRoundRevamp.Instance.steamSounds.Clear();
					StartOfRoundRevamp.Instance.lightBuzz.Clear();
					HUDManagerRevamp component2 = ((Component)HUDManager.Instance).gameObject.GetComponent<HUDManagerRevamp>();
					if (!Object.op_Implicit((Object)(object)component2))
					{
						return;
					}
					component2.blindnessIntensity = 0f;
					component2.concussedIntensity = 0f;
					component.kidnapped = false;
				}
			}
			StartOfRoundRevamp component3 = ((Component)__instance).gameObject.GetComponent<StartOfRoundRevamp>();
			if (Object.op_Implicit((Object)(object)component3))
			{
				component3.Reset();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "DisableShipSpeakerLocalClient")]
		[HarmonyPostfix]
		private static void DisableShipSpeakerLocalClient(StartOfRound __instance)
		{
		}
	}
	[HarmonyPatch(typeof(SteamValveHazard))]
	internal class SteamValveHazardPatch
	{
		[HarmonyPatch(typeof(SteamValveHazard), "Start")]
		[HarmonyPrefix]
		private static void Start(SteamValveHazard __instance)
		{
			SteamLeakRevamp component = ((Component)__instance).gameObject.GetComponent<SteamLeakRevamp>();
			if (!