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 System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BlinkzSoundEffects.Patches;
using GameNetcodeStuff;
using HarmonyLib;
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: AssemblyTitle("BlinkzSoundEffects")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BlinkzSoundEffects")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5496468a-8cda-4a43-b75d-38219dd45751")]
[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 BlinkzSoundEffects
{
	[BepInPlugin("Blinkz.BlinkzSoundMod", "Blinkz Sound Mod", "1.0.13")]
	public class BlinkzSounds : BaseUnityPlugin
	{
		private const string modGUID = "Blinkz.BlinkzSoundMod";

		private const string modName = "Blinkz Sound Mod";

		private const string modVersion = "1.0.13";

		private readonly Harmony harmony = new Harmony("Blinkz.BlinkzSoundMod");

		private static BlinkzSounds Instance;

		internal ManualLogSource mls;

		internal static List<AudioClip> SoundFX;

		internal static AssetBundle Bundle;

		internal static AudioClip[] newSFX;

		public static ConfigEntry<string> Item;

		public static int num;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Item = ((BaseUnityPlugin)this).Config.Bind<string>("General", "Item", "Easter egg", "Default: Easter egg");
			mls = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");
			mls.LogInfo((object)"\r\n       _     _   _____   _       _        _____  \r\n      | |   | | |  ___| | |     | |      /  _  \\ \r\n      | |___| | | |___  | |     | |     |  / \\  |\r\n      |  ___  | |  ___| | |     | |     | (   ) |\r\n      | |   | | | |___  | |___  | |___  |  \\_/  |\r\n      |_|   |_| |_____| |_____| |_____|  \\_____/ \r\n");
			mls.LogInfo((object)"Why are you looking at this?");
			num = 0;
			harmony.PatchAll(typeof(BlinkzSounds));
			harmony.PatchAll(typeof(LootBug));
			harmony.PatchAll(typeof(Mafia));
			harmony.PatchAll(typeof(Nutcracker));
			harmony.PatchAll(typeof(Boombox));
			harmony.PatchAll(typeof(Jester));
			harmony.PatchAll(typeof(Worm));
			harmony.PatchAll(typeof(Butler));
			harmony.PatchAll(typeof(Coilhead));
			harmony.PatchAll(typeof(PlayerDeath));
			harmony.PatchAll(typeof(Puffer));
			harmony.PatchAll(typeof(RadarBooster));
			harmony.PatchAll(typeof(Dog));
			harmony.PatchAll(typeof(Robot));
			harmony.PatchAll(typeof(Giant));
			harmony.PatchAll(typeof(Dropship));
			harmony.PatchAll(typeof(Hello));
			harmony.PatchAll(typeof(Yield));
			harmony.PatchAll(typeof(Thumper));
			harmony.PatchAll(typeof(Spider));
			harmony.PatchAll(typeof(Airhorn));
			harmony.PatchAll(typeof(Charging));
			harmony.PatchAll(typeof(HealingTurret));
			SoundFX = new List<AudioClip>();
			string location = ((BaseUnityPlugin)Instance).Info.Location;
			location = location.TrimEnd("BlinkzSoundEffects.dll".ToCharArray());
			Bundle = AssetBundle.LoadFromFile(location + "blinkzsounds");
			if ((Object)(object)Bundle != (Object)null)
			{
				mls.LogInfo((object)"Got my files :)");
				SoundFX = Bundle.LoadAllAssets<AudioClip>().ToList();
			}
			else
			{
				mls.LogError((object)"Where are my sound files?");
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void HealRpc(Turret turret)
		{
			turret.mainAudio.PlayOneShot(Bundle.LoadAsset<AudioClip>("assets/Heal.wav"));
			turret.farAudio.PlayOneShot(Bundle.LoadAsset<AudioClip>("assets/HealFar.wav"));
		}
	}
}
namespace BlinkzSoundEffects.Patches
{
	[HarmonyPatch(typeof(NoisemakerProp))]
	internal class Airhorn
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(NoisemakerProp __instance)
		{
			__instance.noiseSFX[0] = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Urrrrgghhh.wav");
			__instance.noiseSFXFar[0] = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Urrrrgghhh Far.wav");
		}
	}
	[HarmonyPatch(typeof(BoomboxItem))]
	internal class Boombox
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(BoomboxItem __instance)
		{
		}
	}
	[HarmonyPatch(typeof(ButlerEnemyAI))]
	internal class Butler
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(ButlerEnemyAI __instance)
		{
			AudioClip val = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/BroomSweepDooDoDoo.wav");
			__instance.broomSweepSFX[0] = val;
		}

		[HarmonyPatch("KillEnemy")]
		[HarmonyPostfix]
		private static void DeathSound(ButlerEnemyAI __instance)
		{
			((EnemyAI)__instance).creatureSFX.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Skillz.wav"));
		}
	}
	[HarmonyPatch(typeof(ItemCharger))]
	internal class Charging
	{
		[HarmonyPatch("PlayChargeItemEffectServerRpc")]
		[HarmonyPostfix]
		private static void OverrideAudio(ItemCharger __instance)
		{
			__instance.zapAudio.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/ChargeItUp.wav"));
		}
	}
	[HarmonyPatch(typeof(SpringManAI))]
	internal class Coilhead
	{
		[HarmonyPatch("DoAIInterval")]
		[HarmonyPostfix]
		private static void OverrideAudio(SpringManAI __instance)
		{
			string[] array = new string[2] { "BadLuck", "Unlucky" };
			string text = array[Random.Range(0, array.Length)];
			string[] array2 = new string[2] { "Good Luck", "Too Lucky" };
			string text2 = array2[Random.Range(0, array2.Length)];
			AudioClip[] springNoises = (AudioClip[])(object)new AudioClip[5]
			{
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/SpringHello.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/SpringHmmm.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/SpringWhosThis.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/SpringWobble2Hello.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/SpringWobbleWhatsThis.wav")
			};
			((EnemyAI)__instance).dieSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/KillPlayerSpring" + text + ".wav");
			__instance.enterCooldownSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/" + text2 + ".wav");
			__instance.springNoises = springNoises;
		}
	}
	[HarmonyPatch(typeof(MouthDogAI))]
	internal class Dog
	{
		[HarmonyPatch("enterChaseMode")]
		[HarmonyPostfix]
		private static void OverrideRoar(MouthDogAI __instance)
		{
			((EnemyAI)__instance).creatureSFX.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/RoarYouSuckNoLifeForYou.wav"));
		}

		[HarmonyPatch("EnterLunge")]
		[HarmonyPostfix]
		private static void OverrideAudio(MouthDogAI __instance)
		{
			string[] array = new string[2] { "Woah", "Urgh" };
			string text = array[Random.Range(0, array.Length)];
			AudioClip val = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/" + text + ".wav");
			((EnemyAI)__instance).creatureSFX.PlayOneShot(val);
		}
	}
	[HarmonyPatch(typeof(ItemDropship))]
	internal class Dropship
	{
		[HarmonyPatch("ShipLandedAnimationEvent")]
		[HarmonyPostfix]
		private static void OverrideAudio(ItemDropship __instance)
		{
			Transform transform = ((Component)__instance).transform;
			Transform val = transform.Find("Music");
			AudioSource component = ((Component)val).GetComponent<AudioSource>();
			AudioSource component2 = ((Component)val.Find("Music (1)")).GetComponent<AudioSource>();
			component.clip = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Delfino Plaza.wav");
			component2.clip = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Delfino PlazaFar.wav");
		}
	}
	[HarmonyPatch(typeof(ForestGiantAI))]
	internal class Giant
	{
		[HarmonyPatch("EatPlayerAnimation")]
		[HarmonyPostfix]
		private static void OverrideAudio(ForestGiantAI __instance)
		{
			((EnemyAI)__instance).creatureSFX.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/RoarYouSuckNoLifeForYou.wav"));
		}
	}
	[HarmonyPatch(typeof(Turret))]
	internal class HealingTurret
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(Turret __instance)
		{
			__instance.firingSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/TurretHeal.wav");
			__instance.firingFarSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/TurretHealDistance.wav");
		}
	}
	[HarmonyPatch(typeof(SoundManager))]
	internal class Hello
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(SoundManager __instance)
		{
			__instance.lowAction.clip = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/HelloAction.wav");
		}
	}
	[HarmonyPatch(typeof(JesterAI))]
	internal class Jester
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(JesterAI __instance)
		{
			AudioClip popGoesTheWeaselTheme = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/SawTheme.wav");
			AudioClip popUpSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/IWantToPlayAGame.wav");
			__instance.popGoesTheWeaselTheme = popGoesTheWeaselTheme;
			__instance.popUpSFX = popUpSFX;
		}
	}
	[HarmonyPatch(typeof(HoarderBugAI))]
	internal class LootBug
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(HoarderBugAI __instance)
		{
			AudioClip[] chitterSFX = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Share.wav");
			AudioClip[] angryScreechSFX = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Steal.wav");
			__instance.chitterSFX = chitterSFX;
			__instance.angryScreechSFX = angryScreechSFX;
		}

		[HarmonyPatch("DetectAndLookAtPlayers")]
		[HarmonyPostfix]
		private static void Yippee(HoarderBugAI __instance)
		{
			AudioClip[] chitterSFX = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Share.wav");
			AudioClip[] array = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Steal.wav");
			__instance.chitterSFX = chitterSFX;
		}

		[HarmonyPatch("KillEnemy")]
		[HarmonyPostfix]
		private static void DeathSound(HoarderBugAI __instance)
		{
			((EnemyAI)__instance).creatureSFX.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Skillz.wav"));
		}
	}
	[HarmonyPatch(typeof(BaboonBirdAI))]
	internal class Mafia
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(BaboonBirdAI __instance)
		{
			AudioClip[] cawScreamSFX = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Share.wav");
			AudioClip val = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Steal.wav");
			__instance.cawScreamSFX = cawScreamSFX;
			((EnemyAI)__instance).enemyType.audioClips[3] = val;
			((EnemyAI)__instance).enemyType.audioClips[4] = val;
			((EnemyAI)__instance).enemyType.audioClips[5] = val;
		}

		[HarmonyPatch("KillEnemy")]
		[HarmonyPostfix]
		private static void DeathSound(BaboonBirdAI __instance)
		{
			((EnemyAI)__instance).creatureSFX.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Skillz.wav"));
		}
	}
	[HarmonyPatch(typeof(NutcrackerEnemyAI))]
	internal class Nutcracker
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(NutcrackerEnemyAI __instance)
		{
			__instance.kickSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/You Get the Boot.wav");
		}

		[HarmonyPatch("AimGun")]
		[HarmonyPostfix]
		private static void OverrideAudios(NutcrackerEnemyAI __instance)
		{
			string[] array = new string[3] { "Hello", "Hmmm", "WhatsThis" };
			string text = array[Random.Range(0, array.Length)];
			__instance.aimSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/AlertedSFX" + text + ".wav");
		}

		[HarmonyPatch("KillEnemy")]
		[HarmonyPostfix]
		private static void DeathSound(NutcrackerEnemyAI __instance)
		{
			((EnemyAI)__instance).creatureSFX.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Skillz.wav"));
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerDeath
	{
		[HarmonyPatch("SpawnDeadBody")]
		[HarmonyPostfix]
		private static void deathsoundpatch(ref DeadBodyInfo ___deadBody)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Invalid comparison between Unknown and I4
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Invalid comparison between Unknown and I4
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Invalid comparison between Unknown and I4
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Invalid comparison between Unknown and I4
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Invalid comparison between Unknown and I4
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Invalid comparison between Unknown and I4
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Invalid comparison between Unknown and I4
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Invalid comparison between Unknown and I4
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Invalid comparison between Unknown and I4
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Invalid comparison between Unknown and I4
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Invalid comparison between Unknown and I4
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Invalid comparison between Unknown and I4
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Invalid comparison between Unknown and I4
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Invalid comparison between Unknown and I4
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Invalid comparison between Unknown and I4
			string[] array = new string[2] { "BadLuck", "Unlucky" };
			string text = array[Random.Range(0, array.Length)];
			AudioClip val = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/KillPlayerSpring" + text + ".wav");
			if ((int)___deadBody.causeOfDeath == 0)
			{
			}
			if ((int)___deadBody.causeOfDeath == 1)
			{
			}
			if ((int)___deadBody.causeOfDeath == 2)
			{
				___deadBody.bodyAudio.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Suicide.wav"));
			}
			if ((int)___deadBody.causeOfDeath == 3)
			{
			}
			if ((int)___deadBody.causeOfDeath == 4)
			{
			}
			if ((int)___deadBody.causeOfDeath == 5)
			{
			}
			if ((int)___deadBody.causeOfDeath == 6)
			{
				___deadBody.bodyAudio.PlayOneShot(val);
			}
			if ((int)___deadBody.causeOfDeath == 7)
			{
			}
			if ((int)___deadBody.causeOfDeath == 8)
			{
			}
			if ((int)___deadBody.causeOfDeath == 9)
			{
			}
			if ((int)___deadBody.causeOfDeath == 10)
			{
			}
			if ((int)___deadBody.causeOfDeath == 11)
			{
			}
			if ((int)___deadBody.causeOfDeath == 12)
			{
			}
			if ((int)___deadBody.causeOfDeath == 13)
			{
			}
			if ((int)___deadBody.causeOfDeath == 14)
			{
			}
			if ((int)___deadBody.causeOfDeath == 15)
			{
			}
			if ((int)___deadBody.causeOfDeath == 16)
			{
			}
			if ((int)___deadBody.causeOfDeath != 17)
			{
			}
		}
	}
	[HarmonyPatch(typeof(PufferAI))]
	internal class Puffer
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(PufferAI __instance)
		{
			AudioClip[] frightenSFX = (AudioClip[])(object)new AudioClip[2]
			{
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Mild Inconvience.wav"),
				BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Go Away.wav")
			};
			__instance.frightenSFX = frightenSFX;
		}
	}
	[HarmonyPatch(typeof(RadarBoosterItem))]
	internal class RadarBooster
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(RadarBoosterItem __instance)
		{
			AudioClip pingSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/HelloPing.wav");
			__instance.pingSFX = pingSFX;
		}

		[HarmonyPatch("Flash")]
		[HarmonyPrefix]
		private static void OverrideAudioss(RadarBoosterItem __instance)
		{
			RunAudioOverride(__instance);
		}

		private static async Task RunAudioOverride(RadarBoosterItem __instance)
		{
			if (BlinkzSounds.num == 0)
			{
				__instance.flashSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/NoSightForYou.wav");
				await Task.Delay(2000);
				BlinkzSounds.num = 1;
			}
			else if (BlinkzSounds.num == 1)
			{
				__instance.flashSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Go Away.wav");
				await Task.Delay(2000);
				BlinkzSounds.num = 2;
			}
			else if (BlinkzSounds.num == 2)
			{
				__instance.flashSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Urgh.wav");
				await Task.Delay(2000);
				BlinkzSounds.num = 0;
			}
		}
	}
	[HarmonyPatch(typeof(RadMechAI))]
	internal class Robot
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(RadMechAI __instance)
		{
			string[] array = new string[2] { "Woah", "Urgh" };
			string text = array[Random.Range(0, array.Length)];
			AudioClip val = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/" + text + ".wav");
			((EnemyAI)__instance).enemyType.audioClips[4] = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/You Suck.wav");
			((EnemyAI)__instance).enemyType.audioClips[5] = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/You're Dead.wav");
			((EnemyAI)__instance).enemyType.audioClips[6] = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Go Away.wav");
			((EnemyAI)__instance).enemyType.audioClips[7] = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Hello.wav");
			((EnemyAI)__instance).enemyType.audioClips[8] = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Fuck You.wav");
			((EnemyAI)__instance).enemyType.audioClips[10] = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/No life for you.wav");
		}
	}
	[HarmonyPatch(typeof(SandSpiderAI))]
	internal class Spider
	{
		[HarmonyPatch("KillEnemy")]
		[HarmonyPostfix]
		private static void DeathSound(SandSpiderAI __instance)
		{
			((EnemyAI)__instance).creatureSFX.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Skillz.wav"));
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class YieldSpawn
	{
		internal static ManualLogSource logs = Logger.CreateLogSource("Blinkz.BlinkzSoundMod");

		[HarmonyPatch("GenerateNewFloor")]
		[HarmonyPostfix]
		private static void AddYieldToTitanItemTable(ref SelectableLevel ___currentLevel)
		{
		}
	}
	[HarmonyPatch(typeof(CrawlerAI))]
	internal class Thumper
	{
		[HarmonyPatch("KillEnemy")]
		[HarmonyPostfix]
		private static void DeathSound(CrawlerAI __instance)
		{
			((EnemyAI)__instance).creatureSFX.PlayOneShot(BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/Skillz.wav"));
		}
	}
	[HarmonyPatch(typeof(SandWormAI))]
	internal class Worm
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OverrideAudio(SandWormAI __instance)
		{
			AudioClip emergeFromGroundSFX = BlinkzSounds.Bundle.LoadAsset<AudioClip>("assets/EmergeFromGroundBigUrrrrgghhh.wav");
			__instance.emergeFromGroundSFX = emergeFromGroundSFX;
		}
	}
	[HarmonyPatch(typeof(Shovel))]
	internal class Yield
	{
		[HarmonyPatch("HitShovel")]
		[HarmonyPostfix]
		public static void OverrideAudio(Shovel __instance)
		{
			Logger.CreateLogSource("Blinkz.BlinkzSoundMod").LogInfo((object)"HitShovel");
			if (((GrabbableObject)__instance).itemProperties.itemName == "Yield sign")
			{
				__instance.hitSFX = BlinkzSounds.Bundle.LoadAssetWithSubAssets<AudioClip>("assets/Yield.wav");
			}
		}
	}
}