using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
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 LCSoundTool;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("AIO Memepack")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("AIO Memepack")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("15158709-8f1c-44eb-abf8-90eb79e9d414")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 AIO_Memepack
{
	internal class AudioManager
	{
		private static List<AudioClip> loadedClips = new List<AudioClip>();

		public static AudioClip getAudioClip(string filename)
		{
			if (loadedClips.Count == 0 || !isClipLoaded(filename))
			{
				AudioClip audioClip = SoundTool.GetAudioClip("Dom3005-German_AIO_Memepack", "AIO Memepack", filename);
				((Object)audioClip).name = filename;
				loadedClips.Add(audioClip);
				return audioClip;
			}
			return getLoadedClip(filename);
		}

		public static AudioClip getRandomClip(params string[] filenames)
		{
			return getAudioClip(filenames[Random.Range(0, filenames.Length)]);
		}

		public static AudioClip[] getAllClips(params string[] filenames)
		{
			AudioClip[] array = (AudioClip[])(object)new AudioClip[filenames.Length];
			for (int i = 0; i < filenames.Length; i++)
			{
				array[i] = getAudioClip(filenames[i]);
			}
			return array;
		}

		private static AudioClip getLoadedClip(string filename)
		{
			foreach (AudioClip loadedClip in loadedClips)
			{
				if (((Object)loadedClip).name == filename)
				{
					return loadedClip;
				}
			}
			return null;
		}

		private static bool isClipLoaded(string filename)
		{
			foreach (AudioClip loadedClip in loadedClips)
			{
				if (((Object)loadedClip).name == filename)
				{
					return true;
				}
			}
			return false;
		}

		public static AudioSource createAudioSource(Vector3 position, Transform parent, float distance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			AudioSource obj = Object.Instantiate<GameObject>(new GameObject(), position, Quaternion.identity, parent).AddComponent<AudioSource>();
			obj.maxDistance = distance;
			obj.spatialBlend = 1f;
			obj.rolloffMode = (AudioRolloffMode)1;
			return obj;
		}
	}
	public class AudioCollection
	{
		public List<AudioClip> clips;

		public string collectionName;

		public AudioCollection(List<AudioClip> _clips, string _name)
		{
			clips = _clips;
			collectionName = _name;
		}
	}
	[HarmonyPatch(typeof(BoomboxItem))]
	internal class BoomboxPatch
	{
		private static int currentSongIndex;

		private static PlayerActions playerActions;

		[HarmonyPatch("UseUpBatteries")]
		[HarmonyPrefix]
		public static bool depleteBattery(ref BoomboxItem __instance)
		{
			((GrabbableObject)__instance).insertedBattery.charge = 1f;
			return false;
		}

		[HarmonyPatch("StartMusic")]
		[HarmonyPrefix]
		public static bool StartMusic(ref bool startMusic, ref BoomboxItem __instance)
		{
			if (startMusic)
			{
				__instance.boomboxAudio.clip = NextSong(__instance);
				__instance.boomboxAudio.pitch = 1f;
				__instance.boomboxAudio.Play();
				((GrabbableObject)__instance).isBeingUsed = true;
				__instance.isPlayingMusic = true;
				return false;
			}
			return true;
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static void Update(ref BoomboxItem __instance)
		{
			((GrabbableObject)__instance).insertedBattery.charge = 1f;
		}

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static void Start(ref BoomboxItem __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			BoomboxItem inst = __instance;
			playerActions = new PlayerActions();
			MovementActions movement = playerActions.Movement;
			((MovementActions)(ref movement)).QEItemInteract.performed += delegate(CallbackContext ctx)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				PlayNextSong(ctx, inst);
			};
			movement = playerActions.Movement;
			((MovementActions)(ref movement)).Enable();
		}

		public static void PlayNextSong(CallbackContext context, BoomboxItem __instance)
		{
			if (!((Object)(object)((GrabbableObject)__instance).playerHeldBy == (Object)null) && ((GrabbableObject)__instance).playerHeldBy.playerClientId == StartOfRound.Instance.localPlayerController.playerClientId && ((CallbackContext)(ref context)).control.path.EndsWith("q"))
			{
				((GrabbableObject)__instance).UseItemOnClient(false);
				((GrabbableObject)__instance).UseItemOnClient(true);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public static void PlayNextServerRpc(BoomboxItem __instance, AudioClip nextClip)
		{
			__instance.boomboxAudio.clip = nextClip;
			__instance.boomboxAudio.pitch = 1f;
			__instance.boomboxAudio.Play();
			((GrabbableObject)__instance).isBeingUsed = true;
			__instance.isPlayingMusic = true;
			PlayNextClient(__instance, nextClip);
		}

		[ClientRpc]
		public static void PlayNextClient(BoomboxItem __instance, AudioClip clip)
		{
			__instance.boomboxAudio.clip = clip;
			__instance.boomboxAudio.pitch = 1f;
			__instance.boomboxAudio.Play();
			((GrabbableObject)__instance).isBeingUsed = true;
			__instance.isPlayingMusic = true;
		}

		public static AudioClip NextSong(BoomboxItem __instance)
		{
			return __instance.musicAudios[Random.Range(0, __instance.musicAudios.Length)];
		}
	}
	[HarmonyPatch(typeof(FlowermanAI))]
	internal class BrackenPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start(ref FlowermanAI __instance)
		{
			__instance.crackNeckSFX = AudioManager.getRandomClip("bluetooth.mp3");
		}
	}
	[HarmonyPatch(typeof(HoarderBugAI))]
	internal class BugPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start(ref HoarderBugAI __instance)
		{
			((Component)__instance).gameObject.GetComponentInChildren<MeshFilter>().mesh = null;
			__instance.chitterSFX = AudioManager.getAllClips("happy.mp3", "yippee.mp3", "ich-bins-farid.mp3");
			__instance.angryScreechSFX = AudioManager.getAllClips("bing-bong.mp3", "pimmelberger.mp3");
		}
	}
	internal static class ConfigManager
	{
		private const string CONFIG_FILE_NAME = "aio_memepack.cfg";

		private static ConfigFile _config;

		public static ConfigEntry<float> _flashlightStrength;

		public static ConfigEntry<int> _shovelStrength;

		public static ConfigEntry<int> _dropshipFirstWait;

		public static ConfigEntry<int> _dropshipNormalWait;

		public static ConfigEntry<bool> _enableBoomboxSpawner;

		public static ConfigEntry<bool> _enableInfiniteSprint;

		public static ConfigEntry<bool> _enableFlashlightColors;

		public static ConfigEntry<bool> _disableEarlyLeaveVote;

		public static ConfigEntry<bool> _overrideSoundToolConfig;

		public static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			_config = new ConfigFile(Path.Combine(Paths.ConfigPath, "aio_memepack.cfg"), true);
			_flashlightStrength = _config.Bind<float>("Config", "flashlightIntensity", 5f, "Basegame uses 1.0");
			_shovelStrength = _config.Bind<int>("Config", "shovelStrength", 2, "Damage the shovel does\nBasegame uses 1.0");
			_dropshipFirstWait = _config.Bind<int>("Config", "dropshipFirstWait", 5, "Basegame uses 20");
			_dropshipNormalWait = _config.Bind<int>("Config", "dropshipNormalWait", 5, "Basegame uses 40");
			_enableBoomboxSpawner = _config.Bind<bool>("Config", "enableBoomboxSpawner", true, "Spawns a boombox on the first run of the game");
			_enableInfiniteSprint = _config.Bind<bool>("Config", "enableInfiniteSprint", true, "Allows the player to sprint indefinetly");
			_enableFlashlightColors = _config.Bind<bool>("Config", "enableFlashlightColors", true, "Makes each flashlight have a random color");
			_disableEarlyLeaveVote = _config.Bind<bool>("Config", "disableEarlyLeaveVote", true, "Removes the feature for dead players to vote to leave early");
			_overrideSoundToolConfig = _config.Bind<bool>("Config", "overrideSoundToolConfig", true, "Overrides the network config variables of the LC Soundtool mod, which make this mod work");
		}
	}
	[HarmonyPatch(typeof(DepositItemsDesk))]
	internal class DepositDeskPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start(ref DepositItemsDesk __instance)
		{
			shuffleSounds(__instance);
			AudioSource speakerAudio = __instance.speakerAudio;
			speakerAudio.maxDistance *= 3f;
			AudioSource speakerAudio2 = __instance.speakerAudio;
			speakerAudio2.volume *= 1.5f;
		}

		[HarmonyPatch("OpenShutDoor")]
		[HarmonyPrefix]
		public static void toggleDoor(ref DepositItemsDesk __instance)
		{
			shuffleSounds(__instance);
		}

		private static void shuffleSounds(DepositItemsDesk __instance)
		{
			__instance.rumbleSFX = AudioManager.getRandomClip("traut-euch.mp3", "rehehehe.mp3");
			__instance.doorOpenSFX = AudioManager.getRandomClip("trymacs-hier.mp3", "rehehehe.mp3");
			__instance.rewardGood = AudioManager.getRandomClip("yippee.mp3");
			__instance.microphoneAudios = AudioManager.getAllClips("hier-ist-alles-super.mp3", "chicken-nuggets.mp3", "monte-schonen-abend.mp3", "kaltes-wasser.mp3", "skull-guitar.mp3");
		}
	}
	[HarmonyPatch(typeof(ItemDropship))]
	internal class DropshipPatch
	{
		private static int firstWaitTime;

		private static int normalWaitTime;

		public static Terminal terminal;

		private static StartOfRound playerManager;

		private static List<int> itemDelivery;

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start(ref ItemDropship __instance)
		{
			firstWaitTime = ConfigManager._dropshipFirstWait.Value;
			normalWaitTime = ConfigManager._dropshipNormalWait.Value;
			string[] array = new string[2] { "wuhlmaus-apored.mp3", "chinese-rap-song.mp3" };
			string filename = array[Random.Range(0, array.Length)];
			((Component)((Component)__instance).transform.Find("Music")).GetComponent<AudioSource>().clip = AudioManager.getAudioClip(filename);
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static bool Update(ref ItemDropship __instance)
		{
			object value = Traverse.Create((object)__instance).Field("terminalScript").GetValue();
			terminal = (Terminal)((value is Terminal) ? value : null);
			object value2 = Traverse.Create((object)__instance).Field("playersManager").GetValue();
			playerManager = (StartOfRound)((value2 is StartOfRound) ? value2 : null);
			itemDelivery = Traverse.Create((object)__instance).Field("itemsToDeliver").GetValue() as List<int>;
			if (!((NetworkBehaviour)__instance).IsServer)
			{
				return false;
			}
			if (!__instance.deliveringOrder)
			{
				if (terminal.orderedItemsFromTerminal.Count > 0)
				{
					if (playerManager.shipHasLanded)
					{
						ItemDropship obj = __instance;
						obj.shipTimer += Time.deltaTime;
					}
					if (__instance.playersFirstOrder)
					{
						__instance.playersFirstOrder = false;
						__instance.shipTimer = firstWaitTime;
					}
					if (__instance.shipTimer > (float)normalWaitTime)
					{
						LandShipOnServer(ref __instance);
					}
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch("LandShipOnServer")]
		[HarmonyPrefix]
		private static bool LandShipOnServer(ref ItemDropship __instance)
		{
			__instance.shipTimer = 0f;
			itemDelivery.Clear();
			itemDelivery.AddRange(terminal.orderedItemsFromTerminal);
			terminal.orderedItemsFromTerminal.Clear();
			__instance.playersFirstOrder = false;
			__instance.deliveringOrder = true;
			__instance.LandShipClientRpc();
			return false;
		}
	}
	[HarmonyPatch(typeof(FlashlightItem))]
	internal class FlashlightPatch
	{
		private static Light lightbulb;

		private static float initialIntensity;

		private static float intensityMultiplier;

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start(ref FlashlightItem __instance)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			lightbulb = __instance.flashlightBulb;
			initialIntensity = lightbulb.intensity * intensityMultiplier;
			Light obj = lightbulb;
			obj.spotAngle *= 1.1f;
			if (ConfigManager._enableFlashlightColors.Value)
			{
				float num = (float)Random.Range(50, 100) / 100f;
				float num2 = (float)Random.Range(50, 100) / 100f;
				float num3 = (float)Random.Range(50, 100) / 100f;
				lightbulb.color = new Color(num, num2, num3);
			}
			Item itemProperties = ((GrabbableObject)__instance).itemProperties;
			itemProperties.batteryUsage *= 3f;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void Update(ref FlashlightItem __instance)
		{
			intensityMultiplier = ConfigManager._flashlightStrength.Value;
			initialIntensity = lightbulb.intensity * intensityMultiplier;
		}
	}
	internal class GUIManager
	{
		public static Canvas myCanvas;

		public static TextMeshPro CreateText(Vector2 position, string text)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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)
			GameObject val = new GameObject();
			if ((Object)(object)myCanvas == (Object)null)
			{
				myCanvas = new GameObject("aio_memeCanvas").AddComponent<Canvas>();
			}
			val.transform.SetParent(((Component)myCanvas).transform);
			TextMeshPro val2 = val.AddComponent<TextMeshPro>();
			((TMP_Text)val2).text = text;
			val.transform.position = Vector2.op_Implicit(position);
			return val2;
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal class HudManagerPatch
	{
		private static TextMeshPro shipScrapText;

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static void Start(ref HUDManager __instance)
		{
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void Update(ref HUDManager __instance)
		{
			int num = calculateShiploot();
			int value = Traverse.Create((object)__instance).Field("totalScrapScannedDisplayNum").GetValue<int>();
			((TMP_Text)__instance.totalValueText).text = $"<size=10>Scan: {value}\nIn ship: {num}</size>";
		}

		private static int calculateShiploot()
		{
			GrabbableObject[] componentsInChildren = GameObject.Find("/Environment/HangarShip").GetComponentsInChildren<GrabbableObject>();
			int num = 0;
			GrabbableObject[] array = componentsInChildren;
			foreach (GrabbableObject val in array)
			{
				if (val.itemProperties.isScrap)
				{
					num += val.scrapValue;
				}
			}
			return num;
		}
	}
	internal class ItemManager
	{
		public static List<Item> allItems = StartOfRound.Instance.allItemsList.itemsList;

		public static Item getItemNew(int id)
		{
			return Object.Instantiate<Item>(allItems[id]);
		}

		public static Item getItem(int id)
		{
			return allItems[id];
		}

		public static GameObject spawnItemID(int id, Vector3 pos)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(allItems[id].spawnPrefab, pos, Quaternion.identity, StartOfRound.Instance.propsContainer);
			obj.GetComponent<GrabbableObject>().fallTime = 0f;
			obj.GetComponent<NetworkObject>().Spawn(false);
			return obj;
		}

		public static GameObject spawnItem(Item item, Vector3 pos)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(item.spawnPrefab, pos, Quaternion.identity, StartOfRound.Instance.propsContainer);
			obj.GetComponent<GrabbableObject>().itemProperties = item;
			obj.GetComponent<NetworkObject>().Spawn(false);
			return obj;
		}

		public static void RegisterScrap()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Item item = GenerateItemStats(getItemNew(50), "Jägermeister", 56, 100, 100, "jaegermeister.mp3");
			SetItemModel(item, "Jaeger.prefab", "jaegermeister");
			AddItemToSpawnpool(item, 75);
			Item obj = GenerateItemStats(getItemNew(41), "Chicken Nuggets", 50, 50, 100, "chicken-nuggets.mp3");
			BoxCollider component = obj.spawnPrefab.GetComponent<BoxCollider>();
			component.size *= 2f;
			SetItemModel(obj, "ChickenNuggets.prefab");
			AddItemToSpawnpool(obj, 75);
			LogItemIds();
		}

		public static void PatchItems()
		{
			getItem(1).toolTips = new string[2] { "Toggle on/off: [LMB]", "Next song: [Q]" };
			getItem(1).canBeGrabbedBeforeGameStart = true;
			Shovel component = getItem(10).spawnPrefab.GetComponent<Shovel>();
			component.shovelHitForce *= ConfigManager._shovelStrength.Value;
			getItem(20).grabSFX = AudioManager.getAudioClip("michi.mp3");
			getItem(25).spawnPrefab.GetComponent<NoisemakerProp>().noiseSFX = (AudioClip[])(object)new AudioClip[1] { AudioManager.getAudioClip("goofy-ahh.mp3") };
			getItem(25).spawnPrefab.GetComponent<NoisemakerProp>().noiseSFXFar = (AudioClip[])(object)new AudioClip[1] { AudioManager.getAudioClip("goofy-ahh.mp3") };
			getItem(44).grabSFX = AudioManager.getAudioClip("pickle-rick.mp3");
		}

		private static Item GenerateItemStats(Item baseItem, string itemName, int worth, int min, int max, string grabFX)
		{
			baseItem.itemName = itemName;
			baseItem.creditsWorth = worth;
			baseItem.minValue = min;
			baseItem.maxValue = max;
			baseItem.grabSFX = AudioManager.getAudioClip(grabFX);
			baseItem.itemId = StartOfRound.Instance.allItemsList.itemsList.Count;
			return baseItem;
		}

		private static void SetItemModel(Item item, string prefabName, string bundleName = "items")
		{
			GameObject val = Utils.loadGameObject(prefabName, Utils.loadBundle(bundleName));
			((Object)item.spawnPrefab).name = item.itemName;
			item.spawnPrefab.GetComponent<MeshFilter>().mesh = val.GetComponentInChildren<MeshFilter>().mesh;
			((Renderer)item.spawnPrefab.GetComponent<MeshRenderer>()).materials = ((Renderer)val.GetComponentInChildren<MeshRenderer>()).materials;
			item.spawnPrefab.GetComponent<GrabbableObject>().itemProperties = item;
			((Component)item.spawnPrefab.transform.GetChild(0)).GetComponent<ScanNodeProperties>().headerText = item.itemName;
		}

		private static void AddItemToSpawnpool(Item item, int rarity)
		{
			StartOfRound.Instance.allItemsList.itemsList.Add(item);
			Utils.addItemToAllLevels(item, rarity);
		}

		public static void LogItemIds()
		{
			for (int i = 0; i < allItems.Count; i++)
			{
				MemepackBase.logger.LogInfo((object)$"{i} - {allItems[i]}");
			}
		}
	}
	[HarmonyPatch(typeof(JesterAI))]
	internal class JesterPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start(ref JesterAI __instance)
		{
			__instance.popGoesTheWeaselTheme = AudioManager.getAudioClip("freebird-0.mp3");
			__instance.popUpSFX = AudioManager.getAudioClip("freebird-1.mp3");
		}
	}
	[HarmonyPatch(typeof(StartMatchLever))]
	internal class LeverPatch
	{
		private static bool enableBoomboxSpawner;

		private static bool hasSpawnedBoombox;

		[HarmonyPatch("PullLever")]
		[HarmonyPrefix]
		public static bool PullLever(ref StartMatchLever __instance)
		{
			//IL_00f0: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			int num = Random.Range(1, 19);
			__instance.playersManager.openingHangarDoorAudio = AudioManager.getAudioClip($"weis ({num}).mp3");
			AudioSource shipDoorAudioSource = __instance.playersManager.shipDoorAudioSource;
			shipDoorAudioSource.maxDistance *= 3f;
			AudioSource shipDoorAudioSource2 = __instance.playersManager.shipDoorAudioSource;
			shipDoorAudioSource2.volume *= 1.5f;
			if (__instance.leverHasBeenPulled)
			{
				__instance.StartGame();
				enableBoomboxSpawner = ConfigManager._enableBoomboxSpawner.Value;
				hasSpawnedBoombox = GameObject.Find("/Environment/HangarShip").GetComponentsInChildren<BoomboxItem>().Length != 0;
				if (enableBoomboxSpawner && !hasSpawnedBoombox)
				{
					ItemManager.spawnItemID(1, ((Component)__instance).transform.position + new Vector3(-1f, 2f, 0f));
					hasSpawnedBoombox = true;
				}
			}
			else
			{
				__instance.EndGame();
			}
			MemepackBase.logger.LogInfo((object)((Component)__instance).transform.position);
			return false;
		}

		private static IEnumerator stopPlayerAfter(AudioSource source, float waitFor)
		{
			yield return (object)new WaitForSeconds(waitFor);
			while (source.volume > 0f)
			{
				source.volume -= Time.deltaTime * 0.25f;
			}
			source.Stop();
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal class MenuManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start()
		{
			if (!ConfigManager._overrideSoundToolConfig.Value)
			{
				return;
			}
			foreach (ConfigDefinition key2 in ((BaseUnityPlugin)SoundTool.Instance).Config.Keys)
			{
				string key = key2.Key;
				if (key == "EnableNetworking" || key == "SyncUnityRandomSeed")
				{
					((BaseUnityPlugin)SoundTool.Instance).Config[key2].BoxedValue = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Landmine))]
	internal class MinePatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static void Start(ref Landmine __instance)
		{
			if (((NetworkBehaviour)__instance).NetworkManager.IsHost)
			{
				SetSoundsClientRpc(__instance, AudioManager.getRandomClip("discord-notification.mp3", "vine-boom.mp3", "bonk.mp3"), AudioManager.getRandomClip("was-zitterstn-so.mp3", "bomb-planted.mp3"));
			}
		}

		[ClientRpc]
		private static void SetSoundsClientRpc(Landmine __instance, AudioClip clip1, AudioClip clip2)
		{
			__instance.mineDetonate = clip1;
			__instance.mineDetonateFar = __instance.mineDetonate;
			__instance.minePress = clip2;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start(PlayerControllerB __instance)
		{
			if (ConfigManager._enableInfiniteSprint.Value)
			{
				((Component)__instance.sprintMeterUI).gameObject.SetActive(false);
				__instance.sprintTime = 100f;
			}
		}

		[HarmonyPatch("LateUpdate")]
		[HarmonyPostfix]
		private static void LateUpdate(PlayerControllerB __instance)
		{
			if (ConfigManager._enableInfiniteSprint.Value && __instance.sprintMeter <= 0.5f)
			{
				__instance.sprintMeter = 1f;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "CalculateNormalLookingInput")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CalculateNormalInput(IEnumerable<CodeInstruction> instructions)
		{
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Ldc_R4 && (float)instruction.operand == 60f)
				{
					instruction.operand = 80f;
					break;
				}
			}
			return instructions;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "CalculateSmoothLookingInput")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CalculateSmoothInput(IEnumerable<CodeInstruction> instructions)
		{
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Ldc_R4 && (float)instruction.operand == 60f)
				{
					instruction.operand = 80f;
					break;
				}
			}
			return instructions;
		}

		[HarmonyPatch("KillPlayerClientRpc")]
		[HarmonyPrefix]
		public static void KillPlayerClient(ref PlayerControllerB __instance)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			string[] array = new string[11]
			{
				"auto-machen-so.mp3", "bigmac.mp3", "das-gibt-ne-6.mp3", "ekg.mp3", "fart.mp3", "harry-potter.mp3", "roblox-death.mp3", "skill-issue.mp3", "snore-mimimi.mp3", "vine-boom.mp3",
				"fortnite-knock.mp3"
			};
			AudioClip audioClip = AudioManager.getAudioClip(array[Random.Range(0, array.Length)]);
			AudioManager.createAudioSource(((Component)__instance).transform.position, null, 100f).PlayOneShot(audioClip);
		}
	}
	[BepInPlugin("dom3005.aio_memepack", "AIO Memepack", "1.3.0")]
	public class MemepackBase : BaseUnityPlugin
	{
		private const string mod_guid = "dom3005.aio_memepack";

		private const string mod_name = "AIO Memepack";

		private const string mod_version = "1.3.0";

		private readonly Harmony harmony = new Harmony("dom3005.aio_memepack");

		public static MemepackBase instance;

		internal static ManualLogSource logger;

		private void Awake()
		{
			instance = this;
			logger = Logger.CreateLogSource("dom3005.aio_memepack");
			logger.LogMessage((object)"Loaded AIO Memepack version 1.3.0!");
			ConfigManager.Init();
			harmony.PatchAll();
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManagerPatch
	{
	}
	[HarmonyPatch(typeof(Shovel))]
	internal class ShovelPatch
	{
		[HarmonyPatch("HitShovel")]
		[HarmonyPostfix]
		private static void HitShovel(ref Shovel __instance)
		{
			AudioClip[] allClips = AudioManager.getAllClips("bonk.mp3", "tf2-bonk.mp3", "discord-notification.mp3");
			RoundManager.PlayRandomClip(__instance.shovelAudio, allClips, true, 1f, 0);
		}
	}
	[HarmonyPatch(typeof(SandSpiderAI))]
	internal class SpiderPatch
	{
		[HarmonyPatch("TriggerChaseWithPlayer")]
		[HarmonyPostfix]
		public static void TriggerChase(ref SandSpiderAI __instance)
		{
			((EnemyAI)__instance).creatureSFX.PlayOneShot(AudioManager.getAudioClip("ich-bin-eine-spinne.mp3"));
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("playersFiredGameOver")]
		[HarmonyPrefix]
		private static void playersFiredGameOver(ref StartOfRound __instance)
		{
			string[] array = new string[3] { "outro-song.mp3", "subway-surfer-bass-boosted.mp3", "in-hamburg-sagt-man-tschuss.mp3" };
			AudioClip audioClip = AudioManager.getAudioClip(array[Random.Range(0, array.Length)]);
			__instance.alarmSFX = audioClip;
			__instance.firedVoiceSFX = AudioManager.getRandomClip("monte_maybe_next_time.mp3", "traut-euch.mp3", "was-zitterstn-so.mp3");
		}

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		private static void Start_prefix()
		{
			ItemManager.RegisterScrap();
			ItemManager.PatchItems();
		}
	}
	[HarmonyPatch(typeof(CrawlerAI))]
	internal class ThumperPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start(ref CrawlerAI __instance)
		{
			__instance.hitWallSFX = AudioManager.getAllClips("pimmelberger.mp3");
			((EnemyAI)__instance).dieSFX = AudioManager.getAudioClip("snore-mimimi.mp3");
			__instance.longRoarSFX = AudioManager.getAllClips("was-zitterstn-so.mp3", "chinese-rap-song.mp3", "bing-bong.mp3");
			__instance.eatPlayerSFX = AudioManager.getAudioClip("number-one-victory-royale.mp3");
			__instance.shortRoar = AudioManager.getAudioClip("skull-guitar.mp3");
			__instance.bitePlayerSFX = AudioManager.getAudioClip("heheheha.mp3");
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal class TimeOfDayPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void Update(ref TimeOfDay __instance)
		{
			if (ConfigManager._disableEarlyLeaveVote.Value)
			{
				__instance.votedShipToLeaveEarlyThisRound = true;
			}
		}
	}
	internal class Utils
	{
		private static Dictionary<string, AssetBundle> loadedBundles = new Dictionary<string, AssetBundle>();

		public static AssetBundle loadBundle(string bundlename)
		{
			if (loadedBundles.ContainsKey(bundlename))
			{
				return loadedBundles[bundlename];
			}
			string text = Path.Combine(Paths.PluginPath, "AIO Memepack", bundlename);
			if (!File.Exists(text))
			{
				text = Path.Combine(Paths.PluginPath, "Dom3005-German_AIO_Memepack", "AIO Memepack", bundlename);
				if (!File.Exists(text))
				{
					MemepackBase.logger.LogError((object)("Could not find bundle \"" + bundlename + "\""));
					MemepackBase.logger.LogError((object)(text ?? ""));
					return null;
				}
			}
			MemepackBase.logger.LogInfo((object)text);
			AssetBundle val = AssetBundle.LoadFromFile(text);
			loadedBundles.Add(bundlename, val);
			return val;
		}

		public static GameObject loadGameObject(string filename, AssetBundle bundle)
		{
			return bundle.LoadAsset<GameObject>(filename);
		}

		public static Material loadMaterial(string filename, AssetBundle bundle)
		{
			return bundle.LoadAsset<Material>(filename);
		}

		public static void addItemToAllLevels(Item item, int rarity)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			SpawnableItemWithRarity val = new SpawnableItemWithRarity();
			val.rarity = rarity;
			val.spawnableItem = item;
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			for (int i = 0; i < levels.Length; i++)
			{
				levels[i].spawnableScrap.Add(val);
			}
		}

		public static void ReplaceAllScrap(Item item, int rarity)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			SpawnableItemWithRarity val = new SpawnableItemWithRarity();
			val.rarity = rarity;
			val.spawnableItem = item;
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			foreach (SelectableLevel obj in levels)
			{
				obj.spawnableScrap.Clear();
				obj.maxScrap *= 2;
				obj.minScrap *= 2;
				obj.spawnableScrap.Add(val);
			}
		}

		public static void logComponents(GameObject go)
		{
			Component[] components = go.GetComponents<Component>();
			foreach (Component val in components)
			{
				MemepackBase.logger.LogInfo((object)((object)val).ToString());
			}
		}

		public static void logComponentsRecursively(GameObject go)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in go.transform)
			{
				logComponents(((Component)item).gameObject);
			}
		}

		public static void logChildren(GameObject go)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			foreach (Transform item in go.transform)
			{
				Transform val = item;
				MemepackBase.logger.LogInfo((object)((object)val).ToString());
			}
		}
	}
	[HarmonyPatch(typeof(EnemyVent))]
	internal class VentPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static void Update(ref EnemyVent __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.occupied && __instance.ventAudio.isPlaying)
			{
				AudioSource obj = AudioManager.createAudioSource(((Component)__instance).transform.position, ((Component)__instance).transform, 10f);
				obj.clip = AudioManager.getAudioClip("trymacs-hier.mp3");
				obj.loop = false;
				obj.Play();
			}
		}
	}
	[HarmonyPatch(typeof(WalkieTalkie))]
	internal class WalkietalkiePatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start(ref FlashlightItem __instance)
		{
			Item itemProperties = ((GrabbableObject)__instance).itemProperties;
			itemProperties.batteryUsage *= 3f;
		}
	}
}