using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using BlinkzREPOSoundEffects.Patches;
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("BlinkzREPOSoundEffects")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BlinkzREPOSoundEffects")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("bb0cda16-c6ee-4065-899a-263682eba5a0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BlinkzREPOSoundEffects
{
	[BepInPlugin("BlinkzREPOSounds", "Iggys Memes R.E.P.O.", "0.0.14")]
	public class BlinkzSounds : BaseUnityPlugin
	{
		private const string modGUID = "BlinkzREPOSounds";

		private const string modName = "Iggys Memes R.E.P.O.";

		private const string modVersion = "0.0.14";

		private readonly Harmony harmony = new Harmony("BlinkzREPOSounds");

		private static BlinkzSounds Instance;

		internal ManualLogSource mls;

		internal static List<AudioClip> SoundFX;

		internal static AssetBundle Bundle;

		public static float tripTimer;

		public static bool running;

		public static int teethChatterCount;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("BlinkzREPOSounds");
			mls.LogInfo((object)"\r\n       _     _   _____   _       _        _____  \r\n      | |   | | |  ___| | |     | |      /  _  \\ \r\n      | |___| | | |___  | |     | |     |  / \\  |\r\n      |  ___  | |  ___| | |     | |     | (   ) |\r\n      | |   | | | |___  | |___  | |___  |  \\_/  |\r\n      |_|   |_| |_____| |_____| |_____|  \\_____/ \r\n");
			tripTimer = 0f;
			running = false;
			teethChatterCount = 0;
			harmony.PatchAll(typeof(BlinkzSounds));
			harmony.PatchAll(typeof(Huntsman));
			harmony.PatchAll(typeof(Beamer));
			harmony.PatchAll(typeof(Kidnapper));
			harmony.PatchAll(typeof(Marshmellow));
			harmony.PatchAll(typeof(Eye));
			harmony.PatchAll(typeof(Head));
			harmony.PatchAll(typeof(Gnome));
			harmony.PatchAll(typeof(Baby));
			harmony.PatchAll(typeof(Banger));
			harmony.PatchAll(typeof(Frog));
			harmony.PatchAll(typeof(Items));
			harmony.PatchAll(typeof(ChargingStat));
			harmony.PatchAll(typeof(ShadowChild));
			harmony.PatchAll(typeof(PlayAvatar));
			harmony.PatchAll(typeof(PlayHealth));
			harmony.PatchAll(typeof(Clapper));
			harmony.PatchAll(typeof(Tick));
			harmony.PatchAll(typeof(Doggo));
			harmony.PatchAll(typeof(Oogly));
			harmony.PatchAll(typeof(CartLaser));
			harmony.PatchAll(typeof(Lasergun));
			harmony.PatchAll(typeof(Animal));
			SoundFX = new List<AudioClip>();
			string location = ((BaseUnityPlugin)Instance).Info.Location;
			location = location.TrimEnd("BlinkzREPOSoundEffects.dll".ToCharArray());
			Bundle = AssetBundle.LoadFromFile(location + "blinkzreposounds");
		}
	}
}
namespace BlinkzREPOSoundEffects.Patches
{
	[HarmonyPatch(typeof(EnemyAnimal))]
	internal class Animal
	{
		internal static ManualLogSource mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void Notice(EnemyAnimal __instance)
		{
			__instance.enemyAnimalAnim.attackLoop.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Woah.wav");
		}
	}
	[HarmonyPatch(typeof(EnemyValuableThrower))]
	internal class Baby
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideAudio(EnemyValuableThrower __instance)
		{
			__instance.anim.stunSound.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Wah.wav");
			__instance.anim.hurtSound.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Wah.wav");
		}
	}
	[HarmonyPatch(typeof(EnemyBang))]
	internal class Banger
	{
		internal static ManualLogSource mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("ExplosionTellRPC")]
		[HarmonyPostfix]
		private static void Suicide(EnemyBang __instance)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			AudioSource.PlayClipAtPoint(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Suicide.wav"), ((Component)__instance.anim.enemy).transform.position);
		}
	}
	[HarmonyPatch(typeof(EnemyBeamerAnim))]
	internal class Beamer
	{
		internal static ManualLogSource mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideBeamAudio(EnemyBeamerAnim __instance)
		{
			__instance.soundMeleeKick.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/You get the boot.wav");
		}
	}
	[HarmonyPatch(typeof(SemiLaser))]
	internal class CartLaser
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideBeamAudio(SemiLaser __instance)
		{
			__instance.soundLaserStart.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/CartLaserCannonUrgh.wav");
			__instance.soundLaserStartGlobal.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/CartLaserCannonUrghGlobal.wav");
		}
	}
	[HarmonyPatch(typeof(ChargingStation))]
	internal class ChargingStat
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideAudio(ChargingStation __instance)
		{
			__instance.soundStart.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/ChargeItUp.wav");
		}
	}
	[HarmonyPatch(typeof(EnemyShadow))]
	internal class Clapper
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideClap(EnemyShadow __instance)
		{
			__instance.anim.globalClapSound.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Clap_Clap_Global.wav");
			__instance.anim.globalClapSound.Volume = 2f;
		}
	}
	[HarmonyPatch(typeof(EnemyElsa))]
	internal class Doggo
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void Transform(EnemyElsa __instance)
		{
			__instance.anim.transformHeadLookUpSound.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Come here little boy.wav");
		}
	}
	[HarmonyPatch(typeof(EnemyCeilingEye))]
	internal class Eye
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideAudio(EnemyCeilingEye __instance)
		{
			__instance.eyeAnim.sfxStaringStart = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/EyeStaringStart.wav");
		}
	}
	[HarmonyPatch(typeof(EnemyTumbler))]
	internal class Frog
	{
		internal static ManualLogSource mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void FrogSpawn(EnemyTumbler __instance)
		{
			AudioClip[] sounds = (AudioClip[])(object)new AudioClip[3]
			{
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/CleaverSwingWoah01.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/CleaverSwingWoah02.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/CleaverSwingWoah03.wav")
			};
			__instance.enemyTumblerAnim.sfxCleaverSwing.Sounds = sounds;
		}
	}
	[HarmonyPatch(typeof(EnemyGnome))]
	internal class Gnome
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideAudio(EnemyGnome __instance)
		{
			AudioClip[] sounds = (AudioClip[])(object)new AudioClip[4]
			{
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/GnomeLootForYou0.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/GnomeLootForYou1.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/GnomeLootForYou2.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/GnomeLootForYou3.wav")
			};
			__instance.enemyGnomeAnim.soundPickaxeHit.Sounds = sounds;
		}
	}
	[HarmonyPatch(typeof(EnemyHeadAnimationSystem))]
	internal class Head
	{
		internal static ManualLogSource mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("PlayTeethChatter")]
		[HarmonyPostfix]
		private static void TeethChatter(EnemyHeadAnimationSystem __instance)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (BlinkzSounds.teethChatterCount == 0)
			{
				BlinkzSounds.teethChatterCount++;
				AudioSource.PlayClipAtPoint(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Dododo.wav"), ((Component)__instance).transform.position);
			}
			else if (BlinkzSounds.teethChatterCount == 4)
			{
				BlinkzSounds.teethChatterCount = 0;
			}
			else
			{
				BlinkzSounds.teethChatterCount++;
			}
		}
	}
	[HarmonyPatch(typeof(EnemyHunter))]
	internal class Huntsman
	{
		internal static ManualLogSource mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideAudio(EnemyHunter __instance)
		{
			AudioClip[] aimStartClips = (AudioClip[])(object)new AudioClip[3]
			{
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/ImBlind0.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/ImBlind1.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/ImBlind2.wav")
			};
			__instance.enemyHunterAnim.aimStartClips = aimStartClips;
		}

		[HarmonyPatch("UpdateStateRPC")]
		[HarmonyPostfix]
		private static void UpdateStateRPC(EnemyHunter __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.currentState == 11)
			{
				AudioSource.PlayClipAtPoint(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Woah.wav"), ((Component)__instance.enemy).transform.position);
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObjectImpactDetector))]
	internal class Items
	{
		internal static ManualLogSource mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("BreakRPC")]
		[HarmonyPostfix]
		private static void Break(PhysGrabObjectImpactDetector __instance)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.isValuable)
			{
				FieldInfo field = ((object)__instance).GetType().GetField("impactForce", BindingFlags.Instance | BindingFlags.NonPublic);
				float num = (float)field.GetValue(__instance);
				if (num != 0f)
				{
					AudioSource.PlayClipAtPoint(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Hmmmmm2.wav"), ((Component)__instance).gameObject.transform.position, num / 250f);
				}
				else
				{
					AudioSource.PlayClipAtPoint(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Hmmmmm2.wav"), ((Component)__instance).gameObject.transform.position, 0.5f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemyHidden))]
	internal class Kidnapper
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideAudio(EnemyHidden __instance)
		{
			__instance.enemyHiddenAnim.soundBreatheOutFast.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/FastSteal0.wav");
			__instance.enemyHiddenAnim.soundPlayerMove.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/HiddenPlayerSteal.wav");
			__instance.enemyHiddenAnim.soundPlayerPickup.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Steal.wav");
		}
	}
	[HarmonyPatch(typeof(ItemGunLaser))]
	internal class Lasergun
	{
		internal static ManualLogSource mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("OnStateShootUpdate")]
		[HarmonyPrefix]
		private static void OverrideBeamAudio(ItemGunLaser __instance)
		{
			__instance.semiLaser.soundLaserStart.Pitch = 1f;
		}
	}
	[HarmonyPatch(typeof(EnemyBowtie))]
	internal class Marshmellow
	{
		internal static ManualLogSource mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideAudio(EnemyBowtie __instance)
		{
			__instance.anim.yellStartSound.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Go Away.wav");
		}

		[HarmonyPatch("UpdateStateRPC")]
		[HarmonyPostfix]
		private static void StateLeave(EnemyBowtie __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.currentState == 7)
			{
				AudioSource.PlayClipAtPoint(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/RunAway.wav"), ((Component)__instance.anim.enemy).transform.position);
			}
		}
	}
	[HarmonyPatch(typeof(EnemyOogly))]
	internal class Oogly
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Hmmmm(EnemyOogly __instance)
		{
			__instance.audioSeePlayer.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Whats this.wav");
			__instance.audioSeePlayerGlobal.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Whats this Global.wav");
		}
	}
	[HarmonyPatch(typeof(PlayerAvatar))]
	internal class PlayAvatar
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void OverrideAudio(PlayerAvatar __instance)
		{
			__instance.truckReturn.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/TruckReturnHeal.wav");
		}
	}
	[HarmonyPatch(typeof(PlayerHealth))]
	internal class PlayHealth
	{
		[HarmonyPatch("HealOtherRPC")]
		[HarmonyPostfix]
		private static void Play(PlayerHealth __instance)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			AudioSource.PlayClipAtPoint(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Share.wav"), ((Component)__instance).transform.position);
		}
	}
	[HarmonyPatch(typeof(EnemyThinMan))]
	internal class ShadowChild
	{
		[HarmonyPatch("UpdateState")]
		[HarmonyPostfix]
		private static void OverrideAudio(EnemyThinMan __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.currentState == 1)
			{
				AudioSource.PlayClipAtPoint(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/MildInconvience.wav"), ((Component)__instance.anim.enemy).transform.position);
			}
		}

		[HarmonyPatch("UpdateStateRPC")]
		[HarmonyPostfix]
		private static void OverrideAudioRPC(EnemyThinMan __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.currentState == 1)
			{
				AudioSource.PlayClipAtPoint(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/MildInconvience.wav"), ((Component)__instance.anim.enemy).transform.position);
			}
		}
	}
	[HarmonyPatch(typeof(EnemyTick))]
	internal class Tick
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void Suck(EnemyTick __instance)
		{
			__instance.anim.bigSuckSound.Sounds = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Ah.wav");
		}
	}
}