using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using TDP.CoilHeadStare.Patch;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("CoilHeadStare")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CoilHeadStare")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9d96f0c2-6393-4d02-99d7-34538a0dad5c")]
[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 TDP.CoilHeadStare
{
	[BepInPlugin("TDP.CoilHeadStare", "CoilHeadStare", "1.1.0")]
	public class ModBase : BaseUnityPlugin
	{
		private const string modGUID = "TDP.CoilHeadStare";

		private const string modName = "CoilHeadStare";

		private const string modVersion = "1.1.0";

		private Harmony harmony;

		internal static ModBase instance;

		internal ManualLogSource mls;

		public static ConfigEntry<float> config_timeUntilStare;

		public static ConfigEntry<float> config_maxStareDistance;

		public static ConfigEntry<float> config_turnHeadSpeed;

		public static ConfigEntry<bool> config_shovelReact;

		private void Awake()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
			}
			else
			{
				Object.Destroy((Object)(object)this);
			}
			ConfigFile();
			harmony = new Harmony("TDP.CoilHeadStare");
			harmony.PatchAll(typeof(CoilHeadPatch));
			mls = Logger.CreateLogSource("TDP.CoilHeadStare");
			mls.LogInfo((object)string.Format("{0} {1} loaded. (TUS={2}, MSD={3}, HTS={4}, SR={5})", "CoilHeadStare", "1.1.0", Stare.timeUntilStare, Stare.maxStareDistance, Stare.turnHeadSpeed, CoilHeadPatch.shovelReact));
		}

		private void ConfigFile()
		{
			config_timeUntilStare = ((BaseUnityPlugin)this).Config.Bind<float>("CoilHeadStare", "Time Until Stare", 8f, "Time between moving and looking at closest player (in seconds)");
			config_maxStareDistance = ((BaseUnityPlugin)this).Config.Bind<float>("CoilHeadStare", "Max Stare Distance", 6f, "Coilhead will only stare at players closer than this (for reference: coilhead's height is ca. 4)");
			config_turnHeadSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("CoilHeadStare", "Head Turn Speed", 0.3f, "The speed at which the head turns towards the player");
			config_shovelReact = ((BaseUnityPlugin)this).Config.Bind<bool>("CoilHeadStare", "Head Bounce on Shovel Hit", true, "Should the coilhead spring recoil when hit with a shovel (or with anything else)");
			Stare.timeUntilStare = config_timeUntilStare.Value;
			Stare.maxStareDistance = config_maxStareDistance.Value;
			Stare.turnHeadSpeed = config_turnHeadSpeed.Value;
			CoilHeadPatch.shovelReact = config_shovelReact.Value;
		}
	}
}
namespace TDP.CoilHeadStare.Patch
{
	internal class CoilHeadPatch
	{
		public static bool shovelReact;

		[HarmonyPatch(typeof(EnemyAI), "Start")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void StartPostFix(EnemyAI __instance)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (__instance is SpringManAI)
			{
				Debug.Log((object)"CoilHead found. Adding stare script.");
				Stare stare = ((Component)__instance).gameObject.AddComponent<Stare>();
				stare.Initialize((SpringManAI)__instance);
			}
		}

		[HarmonyPatch(typeof(EnemyAI), "HitEnemy")]
		[HarmonyPrefix]
		public static void HitEnemyPreFix(EnemyAI __instance)
		{
			if (__instance is SpringManAI)
			{
				if ((Object)(object)__instance == (Object)null)
				{
					ModBase.instance.mls.LogError((object)"On player hit Coil Head: Coil Head instance is missing.");
				}
				else if ((Object)(object)__instance.creatureAnimator == (Object)null)
				{
					ModBase.instance.mls.LogError((object)"On player hit Coil Head: Coil Head animator is missing.");
				}
				else if (__instance.creatureAnimator.parameters.All((AnimatorControllerParameter x) => x.name == "springBoing"))
				{
					ModBase.instance.mls.LogError((object)"On player hit Coil Head: Coil Head animatorcontroller is missing the parameter \"springBoing\".");
				}
				else if (shovelReact)
				{
					__instance.creatureAnimator.SetTrigger("springBoing");
				}
			}
		}
	}
	public class Stare : MonoBehaviour
	{
		private SpringManAI coilHeadInstance;

		public static float timeUntilStare;

		public static float maxStareDistance;

		public static float turnHeadSpeed;

		public static bool keepRunningOnDeath;

		public const string headParentBone = "springBone.002";

		private Transform head;

		private float timeSinceMoving;

		private bool isTurningHead;

		private PlayerControllerB stareTarget;

		public void Initialize(SpringManAI instance)
		{
			Debug.Log((object)"Initializing Stare on Coil Head.");
			coilHeadInstance = instance;
			if ((Object)(object)coilHeadInstance == (Object)null)
			{
				ModBase.instance.mls.LogError((object)"Coil Head instance missing. Harmony Patch failed?");
			}
			List<Transform> list = FindChildren(((Component)coilHeadInstance).transform, "springBone.002");
			if (list == null)
			{
				ModBase.instance.mls.LogError((object)"Search for head parent returned null. This should not be possible, something went wrong.");
			}
			else if (list.Count > 0)
			{
				if (list.Last().childCount > 0)
				{
					head = list.Last().GetChild(list.Last().childCount - 1);
				}
				else
				{
					ModBase.instance.mls.LogWarning((object)"Found head parent (springBone.002), but it has no child transforms. (Likely due to an incompatible reskin mod)");
				}
			}
			else
			{
				ModBase.instance.mls.LogError((object)"Could not find head parent bone. Possibly missing or renamed? Head must be parented to \"springBone.002\".");
			}
			if ((Object)(object)head == (Object)null)
			{
				ModBase.instance.mls.LogError((object)"Could not find head transform. Destroying script. (Coil Head should be unaffected by this)");
				Object.Destroy((Object)(object)this);
			}
			else
			{
				ModBase.instance.mls.LogInfo((object)("Found head transform: " + ((Object)head).name));
			}
		}

		private List<Transform> FindChildren(Transform parent, string name)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			List<Transform> list = new List<Transform>();
			foreach (Transform item in parent)
			{
				Transform val = item;
				if (((Object)val).name == name)
				{
					list.Add(val);
				}
				else
				{
					list.AddRange(FindChildren(val, name));
				}
			}
			return list;
		}

		private void Start()
		{
			if ((Object)(object)head != (Object)null)
			{
				ModBase.instance.mls.LogInfo((object)"Stare initialization successful. Note: If a reskin is being used and the head does not turn, it is most likely incompatible.");
			}
			else
			{
				ModBase.instance.mls.LogWarning((object)"Stare initialization unsuccessful. An error has probably occurred.");
			}
		}

		private void Update()
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)coilHeadInstance == (Object)null || (((EnemyAI)coilHeadInstance).isEnemyDead && !keepRunningOnDeath))
			{
				isTurningHead = false;
				stareTarget = null;
				return;
			}
			if ((Object)(object)head == (Object)null)
			{
				ModBase.instance.mls.LogError((object)"Head transform missing. Destroying script.");
				Object.Destroy((Object)(object)this);
				return;
			}
			if (!isTurningHead)
			{
				stareTarget = ((EnemyAI)coilHeadInstance).GetClosestPlayer(false, false, false);
			}
			if (!((Object)(object)stareTarget == (Object)null))
			{
				Vector3 val = ((Component)stareTarget.gameplayCamera).transform.position - head.position;
				float num = Vector3.Distance(head.position, ((Component)((EnemyAI)coilHeadInstance).GetClosestPlayer(false, false, false)).transform.position);
				if ((double)((EnemyAI)coilHeadInstance).creatureAnimator.GetFloat("walkSpeed") > 0.01 || num > maxStareDistance || Vector3.Angle(head.forward, val) < 5f)
				{
					timeSinceMoving = 0f;
				}
				else
				{
					timeSinceMoving += Time.deltaTime;
				}
				if (timeSinceMoving > timeUntilStare)
				{
					isTurningHead = true;
				}
				else
				{
					isTurningHead = false;
				}
				if (isTurningHead)
				{
					head.forward = Vector3.RotateTowards(head.forward, val, turnHeadSpeed * Time.deltaTime, 0f);
				}
			}
		}
	}
}

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LCSoundTool;
using Microsoft.CodeAnalysis;
using TDP.CoilHeadStare.Patch;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CoilheadStareUASoundRedux")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A template for Lethal Company")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+62d1b1ea45c1ba9ac3e7d26a450ccb981c25a03d")]
[assembly: AssemblyProduct("CoilheadStareUASoundRedux")]
[assembly: AssemblyTitle("CoilheadStareUASoundRedux")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CoilheadStareUASoundRedux
{
	[BepInPlugin("CoilheadStareUASoundRedux", "CoilheadStareUASoundRedux", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony _harmony = new Harmony("CoilheadStareUASoundRedux");

		public AudioClip audioClip;

		public static Plugin Instance { get; set; }

		public static ManualLogSource Log => ((BaseUnityPlugin)Instance).Logger;

		public Plugin()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Instance = this;
		}

		private void Awake()
		{
			audioClip = SoundTool.GetAudioClip(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "zelensky.wav");
			Log.LogInfo((object)"Applying patches...");
			ApplyPluginPatch();
			Log.LogInfo((object)"Patches applied");
		}

		private void ApplyPluginPatch()
		{
			_harmony.PatchAll(typeof(CoilHeadStarePatch));
		}
	}
	[HarmonyPatch(typeof(Stare))]
	public class CoilHeadStarePatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void UpdatePlaySound(PlayerControllerB ___stareTarget, bool ___isTurningHead, SpringManAI ___coilHeadInstance)
		{
			if (___isTurningHead && (Object)(object)___stareTarget != (Object)null && (Object)(object)___coilHeadInstance != (Object)null && !((EnemyAI)___coilHeadInstance).creatureVoice.isPlaying)
			{
				((EnemyAI)___coilHeadInstance).creatureVoice.clip = Plugin.Instance.audioClip;
				((EnemyAI)___coilHeadInstance).creatureVoice.Play();
			}
			else if (!___isTurningHead && (Object)(object)___coilHeadInstance != (Object)null && ((EnemyAI)___coilHeadInstance).creatureVoice.isPlaying)
			{
				((EnemyAI)___coilHeadInstance).creatureVoice.Stop();
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "CoilheadStareUASoundRedux";

		public const string PLUGIN_NAME = "CoilheadStareUASoundRedux";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}

using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("GetItOffMe")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("GetItOffMe")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7705f351-3382-4868-84c6-766b9dc54f7c")]
[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 GetItOffMe
{
	[BepInPlugin("GetItOffMe", "GetItOffMe", "1.0.0")]
	internal class GetItOffMeBase : BaseUnityPlugin
	{
		public static PluginLogger logger = new PluginLogger();

		private static GetItOffMeBase Instance;

		private static ConfigEntry<bool> LoggingEnabled;

		private static ConfigEntry<bool> ConfigMechanicEnabled;

		private static ConfigEntry<float> ConfigCentipedeRemovalChance;

		private static ConfigEntry<bool> ConfigCustomIntervalEnabled;

		private static ConfigEntry<float> ConfigRemovalInterval;

		private static ConfigEntry<bool> ConfigSuffocationEnabled;

		private static ConfigEntry<bool> ConfigCustomHurtChance;

		private static ConfigEntry<float> ConfigSuffocationHurtChance;

		private static ConfigEntry<int> ConfigSuffocationDamage;

		private static ConfigEntry<bool> ConfigCentipedeCanDie;

		private static ConfigEntry<float> ConfigCentipedeDeathChance;

		public static bool MechanicEnabled;

		public static float CentipedeRemovalChance;

		public static bool CustomIntervalEnabled;

		public static float RemovalInterval;

		public static bool SuffocationEnabled;

		public static bool CustomHurtChance;

		public static float SuffocationHurtChance;

		public static int SuffocationDamage;

		public static bool CentipedeCanDie;

		public static float CentipedeDeathChance;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			BindConfig();
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "GetItOffMe");
			SetValues();
			logger.LogInfo("Plugin has been awoken!");
		}

		private void BindConfig()
		{
			ConfigCentipedeCanDie = ((BaseUnityPlugin)this).Config.Bind<bool>("Removal Settings", "Can Die", true, "Whether or not the snare flea has a chance of dying after you get it off your head.");
			ConfigCentipedeDeathChance = ((BaseUnityPlugin)this).Config.Bind<float>("Removal Settings", "Death Chance", 0.2f, "The chance in percentage of which the snare flea can die after getting removed from player heads.");
			ConfigSuffocationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Suffocation Settings", "Enabled", true, (ConfigDescription)null);
			ConfigCustomHurtChance = ((BaseUnityPlugin)this).Config.Bind<bool>("Suffocation Settings", "Custom Hurt Chance", true, (ConfigDescription)null);
			ConfigSuffocationHurtChance = ((BaseUnityPlugin)this).Config.Bind<float>("Suffocation Settings", "Suffocation Hurt Chance", 0.35f, "The chance in percentage of which the snare flea will damage you.");
			ConfigSuffocationDamage = ((BaseUnityPlugin)this).Config.Bind<int>("Suffocation Settings", "Damage", 10, (ConfigDescription)null);
			ConfigMechanicEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Disable the mechanics of the mod if it conflicts with other mods.");
			ConfigCentipedeRemovalChance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Removal Chance", 0.25f, "The success rate of players getting rid of snare fleas clinging on their head.");
			ConfigCustomIntervalEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Custom Interval", true, (ConfigDescription)null);
			ConfigRemovalInterval = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Removal Interval", 1f, "The amount of seconds it'll take before player either gets hurt, or before snare flea gets removed");
			LoggingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Debugging", "Logging", true, (ConfigDescription)null);
		}

		private void SetValues()
		{
			logger.EnableLogging(LoggingEnabled.Value);
			MechanicEnabled = ConfigMechanicEnabled.Value;
			CentipedeRemovalChance = ConfigCentipedeRemovalChance.Value;
			CustomIntervalEnabled = ConfigCustomIntervalEnabled.Value;
			RemovalInterval = ConfigRemovalInterval.Value;
			SuffocationEnabled = ConfigSuffocationEnabled.Value;
			CustomHurtChance = ConfigCustomHurtChance.Value;
			SuffocationHurtChance = ConfigSuffocationHurtChance.Value;
			SuffocationDamage = ConfigSuffocationDamage.Value;
			CentipedeCanDie = ConfigCentipedeCanDie.Value;
			CentipedeDeathChance = ConfigCentipedeDeathChance.Value;
		}
	}
	public class PluginInfo
	{
		public const string PLUGIN_GUID = "GetItOffMe";

		public const string PLUGIN_NAME = "GetItOffMe";

		public const string PLUGIN_VERSION = "1.0.0";
	}
	public class PluginLogger
	{
		private static ManualLogSource mls = Logger.CreateLogSource("GetItOffMe");

		private static bool ShouldLog = true;

		public void EnableLogging(bool enabled)
		{
			ShouldLog = enabled;
		}

		public void LogInfo(object data)
		{
			if (ShouldLog)
			{
				mls.LogInfo(data);
			}
		}

		public void LogError(object data)
		{
			if (ShouldLog)
			{
				mls.LogError(data);
			}
		}
	}
}
namespace GetItOffMe.Patches
{
	[HarmonyPatch(typeof(CentipedeAI))]
	internal class CentipedeAIPatch
	{
		private static FieldInfo DamagePlayerInterval = typeof(CentipedeAI).GetField("damagePlayerInterval", BindingFlags.Instance | BindingFlags.NonPublic);

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static void Prefix(CentipedeAI __instance)
		{
			if (GetItOffMeBase.MechanicEnabled && (Object)(object)((Component)__instance).GetComponent<CentipedeRemover>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<CentipedeRemover>();
				GetItOffMeBase.logger.LogInfo("Patched the Snare flea with the Centipede Removal Mechanic.");
			}
		}

		[HarmonyPatch("DamagePlayerOnIntervals")]
		[HarmonyPostfix]
		public static void DamagePlayerOnIntervals_Postfix(ref CentipedeAI __instance)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (!GetItOffMeBase.SuffocationEnabled)
			{
				GetItOffMeBase.logger.LogInfo("Suffocation is disabled. Damage is not going through.");
				return;
			}
			float num = (float)DamagePlayerInterval.GetValue(__instance);
			if (num <= 0f)
			{
				if (Random.value <= GetItOffMeBase.SuffocationHurtChance && GetItOffMeBase.CustomHurtChance)
				{
					__instance.clingingToPlayer.DamagePlayer(GetItOffMeBase.SuffocationDamage, true, true, (CauseOfDeath)5, 0, false, default(Vector3));
					GetItOffMeBase.logger.LogInfo($"Player took {GetItOffMeBase.SuffocationDamage} damage.");
				}
				else
				{
					__instance.clingingToPlayer.DamagePlayer(GetItOffMeBase.SuffocationDamage, true, true, (CauseOfDeath)5, 0, false, default(Vector3));
					GetItOffMeBase.logger.LogInfo($"Player took {GetItOffMeBase.SuffocationDamage} damage.");
				}
				DamagePlayerInterval.SetValue(__instance, 2);
			}
		}
	}
	public class CentipedeRemover : MonoBehaviour
	{
		private CentipedeAI centipede;

		public bool IsClingingToPlayer;

		private void Start()
		{
			centipede = ((Component)this).GetComponent<CentipedeAI>();
			float num = (GetItOffMeBase.CustomIntervalEnabled ? GetItOffMeBase.RemovalInterval : 1f);
			((MonoBehaviour)this).InvokeRepeating("AttemptCentipedeRemoval", num, num);
		}

		private void Update()
		{
			if ((Object)(object)centipede != (Object)null)
			{
				IsClingingToPlayer = (((Object)(object)centipede.clingingToPlayer != (Object)null) ? true : false);
			}
		}

		private void AttemptCentipedeRemoval()
		{
			if ((Object)(object)centipede == (Object)null || !IsClingingToPlayer)
			{
				return;
			}
			if (Random.value <= GetItOffMeBase.CentipedeRemovalChance)
			{
				IsClingingToPlayer = false;
				centipede.StopClingingClientRpc(false);
				centipede.StopClingingServerRpc(false);
				if (GetItOffMeBase.CentipedeCanDie && Random.value <= GetItOffMeBase.CentipedeDeathChance)
				{
					((EnemyAI)centipede).KillEnemy(true);
					GetItOffMeBase.logger.LogInfo("Player yoinked off the snare flea too hard, causing the snare flea to die.");
				}
				((MonoBehaviour)this).CancelInvoke("AttemptCentipedeRemoval");
				GetItOffMeBase.logger.LogInfo("Stopped Calling AttemptCentipedeRemoval because snare flea has already been removed.");
			}
			else
			{
				GetItOffMeBase.logger.LogInfo("Player was unsuccessful in getting the snare flea off their head.");
			}
			GetItOffMeBase.logger.LogInfo($"Hurt Chance -> {GetItOffMeBase.SuffocationHurtChance}({GetItOffMeBase.SuffocationEnabled}) <-> Death Chance -> {GetItOffMeBase.CentipedeDeathChance}({GetItOffMeBase.CentipedeCanDie})");
		}
	}
}

using System;
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 BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GokuBracken.Core;
using GokuBracken.Patches;
using GokuBracken.Scripts;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("GokuBracken")]
[assembly: AssemblyDescription("A mod for Lethal Company that replaces the bracken's model with a model of Goku from the Tenkaichi games")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Vulf")]
[assembly: AssemblyProduct("GokuBracken")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("50feedfa-5dd6-4358-936e-87945c1a8cae")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.5.9.0")]
namespace GokuBracken.Scripts
{
	public class GokuController : MonoBehaviour
	{
		private FlowermanAI FlowermanAI { get; set; }

		private int Variant { get; set; }

		private int[] VariantWeights { get; set; }

		private string VariantName => Variant switch
		{
			0 => "Base Goku", 
			1 => "SSJ Goku", 
			2 => "God Goku", 
			3 => "SSB Goku", 
			_ => "Unknown", 
		};

		private string VariantAssetName => Variant switch
		{
			0 => "baseGokuUnlitPrefab", 
			1 => "ssjGokuPrefab", 
			2 => "godGokuPrefab", 
			3 => "ssbGokuPrefab", 
			_ => "Unknown", 
		};

		private Aura VariantAura => Variant switch
		{
			0 => new Aura(Color.white, Color.black, Color.white, Color.white), 
			1 => new Aura(Color32.op_Implicit(new Color32(byte.MaxValue, (byte)142, (byte)0, byte.MaxValue)), Color32.op_Implicit(new Color32(byte.MaxValue, (byte)216, (byte)0, byte.MaxValue)), Color32.op_Implicit(new Color32(byte.MaxValue, (byte)142, (byte)0, byte.MaxValue)), Color32.op_Implicit(new Color32(byte.MaxValue, (byte)142, (byte)0, byte.MaxValue))), 
			2 => new Aura(Color32.op_Implicit(new Color32(byte.MaxValue, (byte)76, (byte)0, byte.MaxValue)), Color32.op_Implicit(new Color32(byte.MaxValue, (byte)76, (byte)0, byte.MaxValue)), Color32.op_Implicit(new Color32(byte.MaxValue, (byte)0, (byte)0, byte.MaxValue)), Color32.op_Implicit(new Color32(byte.MaxValue, (byte)58, (byte)0, byte.MaxValue))), 
			3 => new Aura(Color32.op_Implicit(new Color32((byte)0, (byte)132, byte.MaxValue, byte.MaxValue)), Color32.op_Implicit(new Color32((byte)85, (byte)172, byte.MaxValue, byte.MaxValue)), Color32.op_Implicit(new Color32((byte)0, (byte)137, byte.MaxValue, byte.MaxValue)), Color32.op_Implicit(new Color32((byte)66, (byte)172, byte.MaxValue, byte.MaxValue))), 
			_ => default(Aura), 
		};

		private GameObject BaseGokuObject { get; set; }

		private GameObject SecondaryGokuObject { get; set; }

		private GameObject GokuEyesObject { get; set; }

		private GameObject AuraObject { get; set; }

		private bool IsAttacking { get; set; }

		private bool IsDead { get; set; }

		private void Start()
		{
			FlowermanAI = ((Component)this).GetComponent<FlowermanAI>();
			VariantWeights = new int[4] { 50, 30, 15, 5 };
			int seed = StartOfRound.Instance.randomMapSeed + Mathf.RoundToInt(StartOfRound.Instance.timeSinceRoundStarted / 10f) * 10;
			SelectGokuVariant(seed);
			HideFlowermanModel();
			CreateGokuModels();
			ReplaceFlowermanSFX();
			UpdateScanNodeData();
			CreateAura();
		}

		private void Update()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Quaternion rotation = ((Component)StartOfRound.Instance.localPlayerController).transform.rotation;
			float num = ((Quaternion)(ref rotation)).eulerAngles.y - 180f;
			AuraObject.transform.rotation = Quaternion.Euler(0f, num, 0f);
			if (((EnemyAI)FlowermanAI).movingTowardsTargetPlayer && !IsAttacking)
			{
				EnterAttackState();
			}
			if (!((EnemyAI)FlowermanAI).movingTowardsTargetPlayer && IsAttacking)
			{
				ExitAttackState();
			}
			if (((EnemyAI)FlowermanAI).isEnemyDead && !IsDead)
			{
				KillGoku();
			}
		}

		private void HideFlowermanModel()
		{
			Renderer[] componentsInChildren = ((Component)((Component)FlowermanAI).transform.Find("FlowermanModel")).GetComponentsInChildren<Renderer>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].enabled = false;
			}
		}

		private void CreateGokuModels()
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			GameObject asset = Assets.GetAsset<GameObject>("baseGokuPrefab");
			BaseGokuObject = Object.Instantiate<GameObject>(asset, ((Component)this).gameObject.transform);
			((Object)BaseGokuObject).name = "Base Goku";
			GameObject asset2 = Assets.GetAsset<GameObject>(VariantAssetName);
			SecondaryGokuObject = Object.Instantiate<GameObject>(asset2, ((Component)this).gameObject.transform);
			((Object)SecondaryGokuObject).name = VariantName;
			SecondaryGokuObject.SetActive(false);
			GameObject asset3 = Assets.GetAsset<GameObject>("gokuEyesPrefab");
			GokuEyesObject = Object.Instantiate<GameObject>(asset3, ((Component)this).gameObject.transform);
			GokuEyesObject.transform.localPosition = new Vector3(0f, 2.7f, 0f);
			((Object)GokuEyesObject).name = "GokuEyes";
		}

		private void ReplaceFlowermanSFX()
		{
			if (ConfigManager.UseMusic.Value)
			{
				FlowermanAI.creatureAngerVoice.clip = Assets.GetAsset<AudioClip>("aggressiveSFX");
			}
			if (ConfigManager.UseVoicelines.Value)
			{
				FlowermanAI.crackNeckSFX = Assets.GetAsset<AudioClip>("baseGokuKillSFX");
				FlowermanAI.crackNeckAudio.clip = Assets.GetAsset<AudioClip>("baseGokuKillSFX");
			}
		}

		private void UpdateScanNodeData()
		{
			((Component)FlowermanAI).GetComponentInChildren<ScanNodeProperties>().headerText = "Son Goku";
		}

		private void CreateAura()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			GameObject asset = Assets.GetAsset<GameObject>("auraPrefab");
			AuraObject = Object.Instantiate<GameObject>(asset, SecondaryGokuObject.transform);
			((Object)AuraObject).name = "Aura";
			MainModule main = ((Component)AuraObject.transform.Find("Outer")).GetComponent<ParticleSystem>().main;
			MainModule main2 = ((Component)AuraObject.transform.Find("Inner")).GetComponent<ParticleSystem>().main;
			MainModule main3 = ((Component)AuraObject.transform.Find("Inner Burst")).GetComponent<ParticleSystem>().main;
			MainModule main4 = ((Component)AuraObject.transform.Find("Bottom")).GetComponent<ParticleSystem>().main;
			((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(VariantAura.OuterColor);
			((MainModule)(ref main2)).startColor = MinMaxGradient.op_Implicit(VariantAura.InnerColor);
			((MainModule)(ref main3)).startColor = MinMaxGradient.op_Implicit(VariantAura.InnerBurstColor);
			((MainModule)(ref main4)).startColor = MinMaxGradient.op_Implicit(VariantAura.BottomColor);
		}

		private void EnterAttackState()
		{
			BaseGokuObject.SetActive(false);
			SecondaryGokuObject.SetActive(true);
			IsAttacking = true;
		}

		private void ExitAttackState()
		{
			BaseGokuObject.SetActive(true);
			SecondaryGokuObject.SetActive(false);
			IsAttacking = false;
		}

		private void KillGoku()
		{
			//IL_003f: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			GokuEyesObject.SetActive(false);
			BaseGokuObject.SetActive(true);
			SecondaryGokuObject.SetActive(false);
			Transform transform = BaseGokuObject.transform;
			Quaternion rotation = BaseGokuObject.transform.rotation;
			float y = ((Quaternion)(ref rotation)).eulerAngles.y;
			rotation = BaseGokuObject.transform.rotation;
			transform.rotation = Quaternion.Euler(-90f, y, ((Quaternion)(ref rotation)).eulerAngles.z);
			if (ConfigManager.UseDeathSound.Value)
			{
				Object.Destroy((Object)(object)Object.Instantiate<GameObject>(Assets.GetAsset<GameObject>("soundContainerPrefab"), BaseGokuObject.transform), 40f);
			}
			IsDead = true;
		}

		private void SelectGokuVariant(int seed)
		{
			Random random = new Random(seed);
			if (VariantWeights.Length == 0)
			{
				Variant = 0;
				return;
			}
			int num = 0;
			for (int i = 0; i < VariantWeights.Length; i++)
			{
				num += VariantWeights[i];
			}
			int num2 = random.Next(0, num);
			for (int j = 0; j < VariantWeights.Length; j++)
			{
				if (num2 < VariantWeights[j])
				{
					Variant = j;
					return;
				}
				num2 -= VariantWeights[j];
			}
			Variant = 0;
		}
	}
	public struct Aura
	{
		public Color OuterColor { get; set; }

		public Color InnerColor { get; set; }

		public Color InnerBurstColor { get; set; }

		public Color BottomColor { get; set; }

		public Aura(Color outerColor, Color innerColor, Color innerBurstColor, Color bottomColor)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			OuterColor = outerColor;
			InnerColor = innerColor;
			InnerBurstColor = innerBurstColor;
			BottomColor = bottomColor;
		}
	}
}
namespace GokuBracken.Patches
{
	[HarmonyPatch]
	internal class EnemyPatches
	{
		[HarmonyPatch(typeof(FlowermanAI), "Start")]
		[HarmonyPostfix]
		public static void CreateGokuModel(FlowermanAI __instance)
		{
			((Component)__instance).gameObject.AddComponent<GokuController>();
		}
	}
	[HarmonyPatch]
	internal class RoundManagementPatches
	{
		private static Transform CardObject { get; set; }

		[HarmonyPatch(typeof(RoundManager), "GenerateNewLevelClientRpc")]
		[HarmonyPostfix]
		public static void GameStart(RoundManager __instance, int randomSeed, int levelID)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (levelID == 0)
			{
				if ((Object)(object)CardObject == (Object)null)
				{
					CardObject = Object.Instantiate<GameObject>(Assets.GetAsset<GameObject>("cardsPrefab")).transform;
				}
				CardObject.position = new Vector3(-37f, 0.94f, -40.84f);
				CardObject.rotation = Quaternion.Euler(new Vector3(0f, 196f, 0f));
				CardObject.localScale = new Vector3(0.15f, 0.15f, 0.15f);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "EndOfGame")]
		[HarmonyPostfix]
		public static void GameEnd(StartOfRound __instance)
		{
			if ((Object)(object)CardObject != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)CardObject).gameObject);
			}
		}
	}
	[HarmonyPatch]
	internal class TerminalPatches
	{
		[HarmonyPatch(typeof(Terminal), "Start")]
		[HarmonyPostfix]
		public static void EditTerminal(Terminal __instance)
		{
			int index = __instance.enemyFiles.FindIndex((TerminalNode e) => ((Object)e).name == "BrackenFile");
			int num = __instance.terminalNodes.allKeywords.ToList().FindIndex((TerminalKeyword e) => ((Object)e).name == "Bracken");
			__instance.enemyFiles[index].creatureName = "Son Goku";
			__instance.enemyFiles[index].displayText = "Hey, you!\nI think it's about time I got a chance to fight.\n";
			__instance.enemyFiles[index].displayVideo = Assets.GetAsset<VideoClip>("gokuLogVideo");
			__instance.terminalNodes.allKeywords[num].word = "goku";
		}
	}
}
namespace GokuBracken.Core
{
	internal static class Assets
	{
		public static AssetBundle AssetBundle { get; private set; }

		private static Dictionary<string, Object> AssetList { get; set; }

		private static string AssemblyName => Assembly.GetExecutingAssembly().FullName.Split(new char[1] { ',' })[0];

		public static void PopulateAssets()
		{
			if ((Object)(object)AssetBundle != (Object)null)
			{
				Logger.LogWarning("Attempted to load the asset bundle but the bundle was not null!");
				return;
			}
			string name = AssemblyName + ".Bundle.gokubracken";
			using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name))
			{
				AssetBundle = AssetBundle.LoadFromStream(stream);
			}
			if ((Object)(object)AssetBundle == (Object)null)
			{
				Logger.LogError("Asset bundle at " + AssemblyName + ".gokubracken failed to load!");
			}
			AssetList = new Dictionary<string, Object>();
			Object[] array = AssetBundle.LoadAllAssets();
			foreach (Object val in array)
			{
				AssetList.Add(val.name, val);
			}
		}

		public static T GetAsset<T>(string name) where T : Object
		{
			if (!AssetList.TryGetValue(name, out var value))
			{
				Logger.LogError("Attempted to load asset of name " + name + " but no asset of that name exists!");
				return default(T);
			}
			T val = (T)(object)((value is T) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogError("Attempted to load an asset of type " + typeof(T).Name + " but asset of name " + name + " does not match this type!");
				return default(T);
			}
			return val;
		}
	}
	internal static class ConfigManager
	{
		public static ConfigEntry<bool> UseSkinVariants { get; private set; }

		public static ConfigEntry<bool> UseVoicelines { get; private set; }

		public static ConfigEntry<bool> UseMusic { get; private set; }

		public static ConfigEntry<bool> UseDeathSound { get; private set; }

		private static ConfigFile Config => GokuBrackenBase.ModConfig;

		public static void InitializeConfig()
		{
			UseSkinVariants = Config.Bind<bool>("Skin Variants", "Use Skin Variants", true, "Controls whether or not to give Goku the chance to spawn as a different form");
			UseVoicelines = Config.Bind<bool>("Sound", "Use Goku Voicelines", true, "Controls whether or not to replace the bracken's kill sound with Goku voicelines");
			UseMusic = Config.Bind<bool>("Sound", "Use UI Music", true, "Controls whether or not to replace the bracken's agressive sound with the Ultra Instinct theme");
			UseDeathSound = Config.Bind<bool>("Sound", "Use Death Sound", true, "Controls whether or not to play a sound on the bracken's death");
		}
	}
	internal static class Logger
	{
		public static void LogInfo(object message)
		{
			GokuBrackenBase.LogSource.LogInfo(message);
		}

		public static void LogWarning(object message)
		{
			GokuBrackenBase.LogSource.LogWarning(message);
		}

		public static void LogError(object message)
		{
			GokuBrackenBase.LogSource.LogError(message);
		}
	}
	[BepInPlugin("Vulf.GokuBracken", "Goku Bracken", "1.5.8")]
	public class GokuBrackenBase : BaseUnityPlugin
	{
		private static GokuBrackenBase _instance;

		private readonly Harmony Harmony = new Harmony("Vulf.GokuBracken");

		internal static GokuBrackenBase Instance
		{
			get
			{
				return _instance;
			}
			set
			{
				if ((Object)(object)_instance == (Object)null)
				{
					_instance = value;
				}
				else
				{
					Object.Destroy((Object)(object)value);
				}
			}
		}

		public static ManualLogSource LogSource => ((BaseUnityPlugin)Instance).Logger;

		public static ConfigFile ModConfig => ((BaseUnityPlugin)Instance).Config;

		private void Awake()
		{
			Instance = this;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Initializing config...");
			ConfigManager.InitializeConfig();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading asset bundle...");
			Assets.PopulateAssets();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Hey it's me! Goku!");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Your files look pretty strong! I'm gonna patch them!");
			Harmony.PatchAll(typeof(GokuBrackenBase));
			Harmony.PatchAll(typeof(EnemyPatches));
			Harmony.PatchAll(typeof(TerminalPatches));
			Harmony.PatchAll(typeof(RoundManagementPatches));
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "Vulf.GokuBracken";

		public const string NAME = "Goku Bracken";

		public const string VERSION = "1.5.8";

		public const string ASSET_BUNDLE_NAME = "gokubracken";
	}
}

using System;
using System.Collections;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("KarmaForBeingAnnoying_UPDATED")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Updated version of the mod \"KarmaForBeingAnnoying\"")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0")]
[assembly: AssemblyProduct("KarmaForBeingAnnoying_UPDATED")]
[assembly: AssemblyTitle("KarmaForBeingAnnoying_UPDATED")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace KarmaForBeingAnnoying_UPDATED
{
	[BepInPlugin("KarmaForBeingAnnoying_UPDATED", "KarmaForBeingAnnoying_UPDATED", "1.1.0")]
	public class Main : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("KarmaForBeingAnnoying_UPDATED");

		private static Main Instance;

		internal static ConfigEntry<bool> AnnoyingItemSetting;

		internal static ConfigEntry<float> ProbabilitySetting;

		internal static ConfigEntry<float> ProbabilityRemoteSetting;

		internal static ConfigEntry<float> ProbabilityAirhornSetting;

		internal static ConfigEntry<float> ProbabilityClownhornSetting;

		internal static ConfigEntry<float> ProbabilityCashRegisterSetting;

		internal static ConfigEntry<float> ProbabilityHairDryerSetting;

		internal static ConfigEntry<float> DelaySetting;

		internal static ConfigEntry<float> KillRangeSetting;

		internal static ConfigEntry<float> DamageRangeSetting;

		internal static ConfigEntry<bool> RemoteSetting;

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			if ((Object)Instance == (Object)null)
			{
				Instance = this;
			}
			SetCFG();
			harmony.PatchAll(typeof(Patches));
		}

		private static void SetCFG()
		{
			AnnoyingItemSetting = ((BaseUnityPlugin)Instance).Config.Bind<bool>("KarmaForBeingAnnoying Settings", "ON OFF switch", true, "Turns functionality on or off");
			ProbabilitySetting = ((BaseUnityPlugin)Instance).Config.Bind<float>("Probability Settings", "General Probability", 0.1f, "Set probability of exploding");
			ProbabilityRemoteSetting = ((BaseUnityPlugin)Instance).Config.Bind<float>("Probability Settings", "Remote Probability", 0.1f, "Set probability of exploding when using Remote");
			ProbabilityAirhornSetting = ((BaseUnityPlugin)Instance).Config.Bind<float>("Probability Settings", "Airhorn Probability", 0.1f, "Set probability of exploding when using Airhorn");
			ProbabilityClownhornSetting = ((BaseUnityPlugin)Instance).Config.Bind<float>("Probability Settings", "Clownhorn Probability", 0.1f, "Set probability of exploding when using Clownhorn");
			ProbabilityCashRegisterSetting = ((BaseUnityPlugin)Instance).Config.Bind<float>("Probability Settings", "Cashregister Probability", 0.1f, "Set probability of exploding when using Cashregister");
			ProbabilityHairDryerSetting = ((BaseUnityPlugin)Instance).Config.Bind<float>("Probability Settings", "Hairdryer Probability", 0.1f, "Set probability of exploding when using Hairdryer");
			DelaySetting = ((BaseUnityPlugin)Instance).Config.Bind<float>("Delay Settings", "General Delay", 0.5f, "Set delay of explosion");
			KillRangeSetting = ((BaseUnityPlugin)Instance).Config.Bind<float>("Kill Range Settings", "General Kill Range", 10f, "Set kill range of explosion");
			DamageRangeSetting = ((BaseUnityPlugin)Instance).Config.Bind<float>("Damage Range Settings", "General Damage Range", 1f, "Set damage range of explosion");
			RemoteSetting = ((BaseUnityPlugin)Instance).Config.Bind<bool>("KarmaForBeingAnnoying Settings", "UseOnRemote", true, "Defines if Remote sets off explosion based on params");
		}
	}
	public class Patches
	{
		private static IEnumerator DelayedExplosion(Vector3 position, bool effect, float killrange, float damagerange, float delay)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			yield return (object)new WaitForSeconds(delay);
			Landmine.SpawnExplosion(position, effect, killrange, damagerange, 50, 0f, (GameObject)null, false);
		}

		[HarmonyPatch(typeof(NoisemakerProp), "ItemActivate")]
		[HarmonyPostfix]
		private static void NoiseMakerPropItemActivatePatch(ref PlayerControllerB ___playerHeldBy, ref NoisemakerProp __instance)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			NetworkBehaviour val = (NetworkBehaviour)___playerHeldBy;
			if ((Main.AnnoyingItemSetting.Value && val.IsOwner && ___playerHeldBy.isPlayerControlled && (!val.IsServer || ___playerHeldBy.isHostPlayerObject)) || ___playerHeldBy.isTestingPlayer)
			{
				float value = Main.ProbabilitySetting.Value;
				switch (((Object)__instance).name.Replace("(Clone)", "").ToLower())
				{
				case "airhorn":
					value = Main.ProbabilityAirhornSetting.Value;
					break;
				case "clownhorn":
					value = Main.ProbabilityClownhornSetting.Value;
					break;
				case "cashregisteritem":
					value = Main.ProbabilityCashRegisterSetting.Value;
					break;
				case "hairdryer":
					value = Main.ProbabilityHairDryerSetting.Value;
					break;
				}
				if (Random.value < value)
				{
					((MonoBehaviour)__instance).StartCoroutine(DelayedExplosion(((Component)val).transform.position, effect: true, Main.KillRangeSetting.Value, Main.DamageRangeSetting.Value, Main.DelaySetting.Value));
				}
			}
		}

		[HarmonyPatch(typeof(RemoteProp), "ItemActivate")]
		[HarmonyPostfix]
		private static void RemotePropPatch(ref PlayerControllerB ___playerHeldBy, ref RemoteProp __instance)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkBehaviour val = (NetworkBehaviour)__instance;
			if (((Main.RemoteSetting.Value && val.IsOwner && ___playerHeldBy.isPlayerControlled && (!val.IsServer || ___playerHeldBy.isHostPlayerObject)) || ___playerHeldBy.isTestingPlayer) && Random.value < Main.ProbabilityRemoteSetting.Value)
			{
				((MonoBehaviour)__instance).StartCoroutine(DelayedExplosion(((Component)val).transform.position, effect: true, Main.KillRangeSetting.Value, Main.DamageRangeSetting.Value, Main.DelaySetting.Value));
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "KarmaForBeingAnnoying_UPDATED";

		public const string PLUGIN_NAME = "KarmaForBeingAnnoying_UPDATED";

		public const string PLUGIN_VERSION = "1.1.0";
	}
}