using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Diversity.Monsters;
using Diversity.Patches;
using Diversity.Player;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;

[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: 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;
		}
	}
}
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<bool> playerRegen;

		public static ConfigEntry<bool> playerDying;

		public static void Load()
		{
			spiderRevamp = Diversity.config.Bind<bool>("Monster", "SpiderRevamp", true, "Should spider revamp be enabled?");
			spiderSlowAmount = Diversity.config.Bind<float>("Monster", "SpiderSlow", 0.8f, "How much slown should spiders be on hit?");
			crawlerRevamp = Diversity.config.Bind<bool>("Monster", "CrawlerRevamp", true, "Should crawler revamp be enabled?");
			crawlerSlowAmount = Diversity.config.Bind<float>("Monster", "CrawlerSlow", 0.9f, "How much slown should crawlers be on hit?");
			centipedeRevamp = Diversity.config.Bind<bool>("Monster", "CentipedeRevamp", true, "Should centipede revamp be enabled?");
			clickAmount = Diversity.config.Bind<int>("Monster", "ClickAmount", 25, "How many times should you have to click to remove the centipede from someone's head?");
			playerRegen = Diversity.config.Bind<bool>("Player", "PlayerRegen", false, "Should players be able to regen?");
			playerDying = Diversity.config.Bind<bool>("Player", "PlayerDying", false, "Should a custom player dying sound be enabled?");
		}
	}
	public class Content
	{
		public class CustomItem
		{
			public string name = "";

			public string itemPath = "";

			public string infoPath = "";

			public Action<Item> itemAction = delegate
			{
			};

			public bool enabled = true;

			public CustomItem(string name, string itemPath, string infoPath, Action<Item> action = null)
			{
				this.name = name;
				this.itemPath = itemPath;
				this.infoPath = infoPath;
				if (action != null)
				{
					itemAction = action;
				}
			}

			public static CustomItem Add(string name, string itemPath, string infoPath = null, Action<Item> action = null)
			{
				return new CustomItem(name, itemPath, infoPath, action);
			}
		}

		public class CustomShopItem : CustomItem
		{
			public int itemPrice;

			public CustomShopItem(string name, string itemPath, string infoPath = null, int itemPrice = 0, Action<Item> action = null)
				: base(name, itemPath, infoPath, action)
			{
				this.itemPrice = itemPrice;
			}

			public static CustomShopItem Add(string name, string itemPath, string infoPath = null, int itemPrice = 0, Action<Item> action = null, bool enabled = true)
			{
				return new CustomShopItem(name, itemPath, infoPath, itemPrice, action)
				{
					enabled = enabled
				};
			}
		}

		public static AssetBundle MainAssets;

		public static List<CustomItem> customItems;

		public static Dictionary<string, GameObject> Prefabs = new Dictionary<string, GameObject>();

		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 static void Load()
		{
			TryLoadAssets();
			customItems = new List<CustomItem> { CustomShopItem.Add("Bandages", "assets/custom/diversity/bandage.prefab", "assets/custom/diversity/bandageinfo.json", 25) };
			foreach (CustomItem customItem in customItems)
			{
				if (customItem.enabled)
				{
					Item val = MainAssets.LoadAsset<Item>(customItem.itemPath);
					if (customItem is CustomShopItem)
					{
						TerminalNode val2 = MainAssets.LoadAsset<TerminalNode>(customItem.infoPath);
						Diversity.mls.LogInfo((object)$"Registering shop item {customItem.name} with price {((CustomShopItem)customItem).itemPrice}");
						Items.RegisterShopItem(val, (TerminalNode)null, (TerminalNode)null, val2, ((CustomShopItem)customItem).itemPrice);
					}
				}
			}
			Diversity.mls.LogInfo((object)"Custom content loaded!");
		}
	}
	[BepInPlugin("Chaos.Diversity", "Diversity", "1.0.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Diversity : BaseUnityPlugin
	{
		private const string modGUID = "Chaos.Diversity";

		private const string modName = "Diversity";

		private const string modVersion = "1.0.2";

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

		public static Diversity Instance;

		public static ManualLogSource mls;

		public static ConfigFile config;

		private void Awake()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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();
			GameObject val = new GameObject("Diversity");
			val.AddComponent<DiversityBehaviour>();
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)val);
			mls.LogInfo((object)"Diversity GameObject created.");
			harmony.PatchAll(typeof(Diversity));
			harmony.PatchAll(typeof(PlayerControllerBPatch));
			harmony.PatchAll(typeof(SandSpiderAIPatch));
			harmony.PatchAll(typeof(CrawlerAIPatch));
			mls.LogInfo((object)"Diversity started.");
		}
	}
	public class DiversityBehaviour : MonoBehaviour
	{
		public void Update()
		{
			SandSpiderAI[] array = (SandSpiderAI[])(object)Object.FindObjectsOfType(typeof(SandSpiderAI));
			if (Configuration.spiderRevamp.Value)
			{
				SandSpiderAI[] array2 = array;
				foreach (SandSpiderAI val in array2)
				{
					if ((Object)(object)((Component)val).gameObject.GetComponent<SpiderRevamp>() == (Object)null)
					{
						((Component)val).gameObject.AddComponent<SpiderRevamp>();
						Diversity.mls.LogInfo((object)("Added SpiderRevamp to: " + ((Object)((Component)val).gameObject).name));
					}
				}
			}
			CrawlerAI[] array3 = (CrawlerAI[])(object)Object.FindObjectsOfType(typeof(CrawlerAI));
			if (Configuration.crawlerRevamp.Value)
			{
				CrawlerAI[] array4 = array3;
				foreach (CrawlerAI val2 in array4)
				{
					if ((Object)(object)((Component)val2).gameObject.GetComponent<CrawlerRevamp>() == (Object)null)
					{
						((Component)val2).gameObject.AddComponent<CrawlerRevamp>();
						Diversity.mls.LogInfo((object)("Added CrawlerRevamp to: " + ((Object)((Component)val2).gameObject).name));
					}
				}
			}
			PlayerControllerB[] array5 = (PlayerControllerB[])(object)Object.FindObjectsOfType(typeof(PlayerControllerB));
			if (Configuration.playerDying.Value)
			{
				PlayerControllerB[] array6 = array5;
				foreach (PlayerControllerB val3 in array6)
				{
					if ((Object)(object)((Component)val3).gameObject.GetComponent<PlayerDying>() == (Object)null)
					{
						((Component)val3).gameObject.AddComponent<PlayerDying>();
						Diversity.mls.LogInfo((object)("Added PlayerDying to: " + ((Object)((Component)val3).gameObject).name));
					}
				}
			}
			CentipedeAI[] array7 = (CentipedeAI[])(object)Object.FindObjectsOfType(typeof(CentipedeAI));
			if (!Configuration.centipedeRevamp.Value)
			{
				return;
			}
			CentipedeAI[] array8 = array7;
			foreach (CentipedeAI val4 in array8)
			{
				if ((Object)(object)((Component)val4).gameObject.GetComponent<CentipedeRevamp>() == (Object)null)
				{
					((Component)val4).gameObject.AddComponent<CentipedeRevamp>();
					Diversity.mls.LogInfo((object)("Added CentipedeRevamp to: " + ((Object)((Component)val4).gameObject).name));
				}
			}
		}
	}
}
namespace Diversity.Player
{
	internal class PlayerDying : MonoBehaviour
	{
		private PlayerControllerB player;

		private AudioSource audio;

		private GameObject obj;

		private void Start()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			obj = new GameObject("DyingAudio");
			player = ((Component)this).gameObject.GetComponent<PlayerControllerB>();
			obj.transform.SetParent(((Component)player.thisPlayerBody).gameObject.transform);
			audio = obj.gameObject.AddComponent<AudioSource>();
			((Behaviour)audio).enabled = false;
			audio.loop = true;
			audio.playOnAwake = true;
			audio.clip = Content.MainAssets.LoadAsset<AudioClip>("assets/custom/diversity/audio/player/dying.mp3");
			audio.spatialBlend = 1f;
			audio.minDistance = 5f;
			audio.maxDistance = 15f;
			audio.volume = 1f;
			audio.rolloffMode = (AudioRolloffMode)1;
			audio.bypassEffects = true;
			audio.bypassListenerEffects = true;
		}
	}
}
namespace Diversity.Patches
{
	internal class CrawlerAIPatch
	{
		private static CrawlerRevamp crawler;

		[HarmonyPatch(typeof(CrawlerAI), "HitEnemy")]
		[HarmonyPrefix]
		public static void Slow(CrawlerAI __instance)
		{
			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(PlayerControllerB))]
	public class PlayerControllerBPatch
	{
		private static AudioSource audio;

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void regenDisabled(ref float ___healthRegenerateTimer)
		{
			if (!Configuration.playerRegen.Value)
			{
				___healthRegenerateTimer = 1f;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		private static void Dying(PlayerControllerB __instance, ref int ___health)
		{
			if (!Object.op_Implicit((Object)(object)((Component)__instance.thisPlayerBody).transform.Find("DyingAudio")) || !Configuration.playerDying.Value)
			{
				return;
			}
			audio = ((Component)((Component)__instance.thisPlayerBody).transform.Find("DyingAudio")).GetComponent<AudioSource>();
			if (Object.op_Implicit((Object)(object)audio))
			{
				if (___health < 20)
				{
					((Behaviour)audio).enabled = true;
				}
				else
				{
					((Behaviour)audio).enabled = false;
				}
			}
		}
	}
	[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!");
			}
		}
	}
}
namespace Diversity.Monsters
{
	public class CentipedeRevamp : MonoBehaviour
	{
		private CentipedeAI centipede;

		private InteractTrigger centipedeInteractTrigger;

		public int clicks;

		private void Start()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			centipede = ((Component)this).gameObject.GetComponent<CentipedeAI>();
			GameObject val = Object.Instantiate<GameObject>(Content.MainAssets.LoadAsset<GameObject>("assets/custom/centipede/interactobject.prefab"), new Vector3(0f, 0f, 0f), Quaternion.identity);
			val.GetComponent<NetworkObject>().Spawn(true);
			Diversity.mls.LogInfo((object)"Loaded centipede prefab!");
			val.transform.SetParent(((Component)this).transform);
			Diversity.mls.LogInfo((object)"Appended centipede prefab!");
			centipedeInteractTrigger = val.GetComponent<InteractTrigger>();
			Diversity.mls.LogInfo((object)"InteractTrigger fetched!");
			centipedeInteractTrigger.interactable = true;
			centipedeInteractTrigger.onInteract = new InteractEvent();
			((UnityEvent<PlayerControllerB>)(object)centipedeInteractTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)Free);
		}

		public void Free(PlayerControllerB player)
		{
			Diversity.mls.LogInfo((object)"Player interacted with a centipede!");
		}

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)centipede) && (Object)(object)centipede.clingingToPlayer != (Object)null)
			{
				Diversity.mls.LogInfo((object)"Centipede latched on head!!");
			}
		}
	}
	public class CrawlerRevamp : MonoBehaviour
	{
		private CrawlerAI crawler;

		private static float slowAmount = Configuration.crawlerSlowAmount.Value;

		private static float timeElapsed = 0f;

		private static float cooldown = 0f;

		public bool onCooldown = false;

		public bool hasBeenhit = false;

		public float previousAgentSpeed = 0f;

		public float previousAgentAcceleration = 0f;

		public float currentAgentSpeed = 0f;

		public float currentAgentAcceleration = 0f;

		private void Start()
		{
			crawler = ((Component)this).gameObject.GetComponent<CrawlerAI>();
		}

		private void Update()
		{
			if (!Object.op_Implicit((Object)(object)crawler))
			{
				return;
			}
			if (hasBeenhit)
			{
				if (timeElapsed < 2f)
				{
					currentAgentSpeed = Mathf.Lerp(currentAgentSpeed - currentAgentSpeed * slowAmount, previousAgentSpeed, timeElapsed / 2f);
					currentAgentAcceleration = Mathf.Lerp(currentAgentAcceleration - currentAgentAcceleration * slowAmount, previousAgentAcceleration + 5f, timeElapsed / 2f);
					timeElapsed += Time.deltaTime;
					Diversity.mls.LogInfo((object)("Time elapsed: " + timeElapsed));
				}
				else
				{
					currentAgentSpeed = previousAgentSpeed;
					currentAgentAcceleration = previousAgentAcceleration;
				}
				if (currentAgentSpeed == previousAgentSpeed)
				{
					hasBeenhit = false;
				}
				((EnemyAI)crawler).agent.speed = currentAgentSpeed;
				((EnemyAI)crawler).agent.acceleration = currentAgentAcceleration;
			}
			if (onCooldown)
			{
				cooldown += Time.deltaTime;
			}
			if (onCooldown && cooldown > 2f && hasBeenhit)
			{
				Diversity.mls.LogInfo((object)"Crawler debuff hit is over.");
				hasBeenhit = false;
				timeElapsed = 0f;
			}
			if (onCooldown && cooldown > 3f)
			{
				Diversity.mls.LogInfo((object)"Crawler debuff cooldown is over.");
				onCooldown = false;
				cooldown = 0f;
			}
		}
	}
	public class SpiderRevamp : MonoBehaviour
	{
		private SandSpiderAI spider;

		private static float slowAmount = Configuration.spiderSlowAmount.Value;

		private static float timeElapsed = 0f;

		private static float cooldown = 0f;

		public bool onCooldown = false;

		public bool hasBeenhit = false;

		public float previousAgentSpeed = 0f;

		public float previousSpiderSpeed = 0f;

		public float currentAgentSpeed = 0f;

		public float currentSpiderSpeed = 0f;

		private void Start()
		{
			spider = ((Component)this).gameObject.GetComponent<SandSpiderAI>();
		}

		private void Update()
		{
			if (!Object.op_Implicit((Object)(object)spider))
			{
				return;
			}
			if (hasBeenhit)
			{
				if (timeElapsed < 1f)
				{
					currentSpiderSpeed = Mathf.Lerp(currentSpiderSpeed - currentSpiderSpeed * slowAmount, previousSpiderSpeed, timeElapsed / 1f);
					currentAgentSpeed = Mathf.Lerp(currentAgentSpeed - currentAgentSpeed * slowAmount, previousAgentSpeed, timeElapsed / 1f);
					timeElapsed += Time.deltaTime;
					Diversity.mls.LogInfo((object)("Time elapsed: " + timeElapsed));
				}
				else
				{
					currentSpiderSpeed = previousSpiderSpeed;
					currentAgentSpeed = previousAgentSpeed;
				}
				if (currentSpiderSpeed == previousSpiderSpeed)
				{
					hasBeenhit = false;
				}
				spider.spiderSpeed = currentSpiderSpeed;
				((EnemyAI)spider).agent.speed = currentAgentSpeed;
				if (currentSpiderSpeed > 0f)
				{
					((EnemyAI)spider).creatureAnimator.SetBool("moving", true);
				}
				else
				{
					((EnemyAI)spider).creatureAnimator.SetBool("moving", false);
				}
			}
			if (onCooldown)
			{
				cooldown += Time.deltaTime;
			}
			if (onCooldown && cooldown > 1f && hasBeenhit)
			{
				Diversity.mls.LogInfo((object)"Spider debuff hit is over.");
				hasBeenhit = false;
				timeElapsed = 0f;
			}
			if (onCooldown && cooldown > 3f)
			{
				Diversity.mls.LogInfo((object)"Spider debuff cooldown is over.");
				onCooldown = false;
				cooldown = 0f;
			}
		}
	}
}
namespace Diversity.Items
{
	public class Bandages : GrabbableObject
	{
		private PlayerControllerB previousPlayerHeldBy;

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			if (((NetworkBehaviour)this).IsOwner)
			{
				Heal();
			}
		}

		public override void EquipItem()
		{
			((GrabbableObject)this).EquipItem();
			if ((Object)(object)base.playerHeldBy != (Object)null)
			{
				previousPlayerHeldBy = base.playerHeldBy;
			}
		}

		private void Heal()
		{
			previousPlayerHeldBy.health = Mathf.Clamp(previousPlayerHeldBy.health + 20, 0, 100);
			((GrabbableObject)this).DestroyObjectInHand(previousPlayerHeldBy);
		}
	}
}