using System;
using System.Collections;
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.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using PersonalBoombox.Patches;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("PersonalBoombox")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PersonalBoombox")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("90672a7b-b084-4f8d-9d78-46affb7b97e7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PersonalBoombox
{
	public static class Assets
	{
		[Serializable]
		private class PBDataJson
		{
			public string name;

			public string description;

			public int price;

			public float volume;

			public int red;

			public int blue;

			public int green;

			public Color color;

			public string feedback;

			public static PBDataJson GetData(string path)
			{
				if (File.Exists(path))
				{
					try
					{
						string json = File.ReadAllText(path);
						PBDataJson pBDataJson = CreateFromJson(json);
						pBDataJson.FillMissingValues();
						pBDataJson.AdjustValues();
						pBDataJson.feedback = "Loaded data.json file";
						return pBDataJson;
					}
					catch
					{
						return GetDefault("Error reading data.json file".CreateError());
					}
				}
				return GetDefault("Missing data.json file".CreateWarning());
			}

			public static PBDataJson GetDefault(string feedback)
			{
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				PBDataJson pBDataJson = new PBDataJson();
				pBDataJson.feedback = feedback;
				pBDataJson.name = "Untitled";
				pBDataJson.description = "Missing Description";
				pBDataJson.price = 60;
				pBDataJson.volume = 0.4f;
				pBDataJson.red = 255;
				pBDataJson.blue = 255;
				pBDataJson.green = 255;
				pBDataJson.color = Color.white;
				return pBDataJson;
			}

			private void FillMissingValues()
			{
				if (string.IsNullOrWhiteSpace(name))
				{
					name = "Untitled";
				}
				if (string.IsNullOrWhiteSpace(description))
				{
					description = "Missing Description";
				}
			}

			private void AdjustValues()
			{
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				int length = Mathf.Min(name.Length, 20);
				name = name.Substring(0, length);
				price = Mathf.Clamp(price, 5, 1000);
				volume = Mathf.Clamp(volume, 0.1f, SyncedInstance<PluginConfig>.Default.maxVolumeValue);
				red = Mathf.Clamp(red, 0, 255);
				blue = Mathf.Clamp(blue, 0, 255);
				green = Mathf.Clamp(green, 0, 255);
				color = new Color((float)red / 255f, (float)green / 255f, (float)blue / 255f, 1f);
			}

			private static PBDataJson CreateFromJson(string json)
			{
				return JsonUtility.FromJson<PBDataJson>(json);
			}

			public string ToJson()
			{
				return JsonUtility.ToJson((object)this);
			}
		}

		private const string mainAssetBundleName = "personalboombox";

		public const int prefabCopyCount = 15;

		public static AssetBundle MainAssetBundle = null;

		public static GameObject originalPrefab;

		public static GameObject[] prefabCopies;

		public static GameObject canvasPrefab;

		public static GameObject volumeControlCanvasPrefab;

		public static Sprite boomboxSprite;

		public static int LimitExceedCounter = 0;

		public static int BoomboxesLoading = 0;

		private static readonly string[] musicExts = new string[3] { "mp3", "ogg", "wav" };

		private static ManualLogSource logger => PersonalBoomboxPlugin.Instance.logger;

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

		public static void LoadAssetBundle()
		{
			if ((Object)(object)MainAssetBundle == (Object)null)
			{
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetAssemblyName() + ".personalboombox");
				MainAssetBundle = AssetBundle.LoadFromStream(stream);
			}
			originalPrefab = Assets.Load<GameObject>("prefab", onlyReportErrors: true);
			prefabCopies = (GameObject[])(object)new GameObject[15];
			for (int i = 0; i < 15; i++)
			{
				GameObject val = Assets.Load<GameObject>($"prefab{i + 1}", onlyReportErrors: false);
				prefabCopies[i] = val;
			}
			canvasPrefab = Assets.Load<GameObject>("debugCanvas", onlyReportErrors: true);
			volumeControlCanvasPrefab = Assets.Load<GameObject>("volumeControlCanvas", onlyReportErrors: true);
			boomboxSprite = Assets.Load<Sprite>("boomboxIcon", onlyReportErrors: true);
		}

		public static T Load<T>(string name, bool onlyReportErrors = true) where T : Object
		{
			if ((Object)(object)MainAssetBundle == (Object)null)
			{
				logger.LogError((object)"Trying to load in asset but asset bundle is missing");
				return default(T);
			}
			if (onlyReportErrors)
			{
				logger.LogInfo((object)("Loading asset " + name));
			}
			return MainAssetBundle.LoadAsset<T>(name);
		}

		public static void LoadMusicFolders()
		{
			List<PersonalBoomboxPlugin.RequestData> requests = PersonalBoomboxPlugin.requests;
			List<PersonalBoomboxPlugin.PBData> list = new List<PersonalBoomboxPlugin.PBData>();
			int num = 0;
			foreach (PersonalBoomboxPlugin.RequestData item in requests)
			{
				string path = item.path;
				string[] directories = Directory.GetDirectories(path);
				string[] array = directories;
				foreach (string directory in array)
				{
					logger.LogInfo((object)("Reading from " + path + "!"));
					try
					{
						CreateFromDirectory(directory, list, num++, item);
					}
					catch (Exception ex)
					{
						logger.LogError((object)("Error loading at " + path));
						logger.LogError((object)ex.ToString());
					}
				}
			}
			list.Sort((PersonalBoomboxPlugin.PBData first, PersonalBoomboxPlugin.PBData second) => first.name.CompareTo(second.name));
			num = 0;
			foreach (PersonalBoomboxPlugin.PBData item2 in list)
			{
				char c = (char)(65 + num);
				item2.prefixName = $"pb{c}";
				item2.boomboxName = item2.prefixName + " " + item2.name;
				((Object)item2.prefab).name = item2.boomboxName;
				num++;
			}
			PersonalBoomboxPlugin.data = list;
		}

		private static void CreateFromDirectory(string directory, List<PersonalBoomboxPlugin.PBData> data, int index, PersonalBoomboxPlugin.RequestData request)
		{
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 15)
			{
				logger.LogWarning((object)$"Loading too many boomboxes. There is a limit of {15}");
				LimitExceedCounter++;
				return;
			}
			string path = Path.Combine(directory, "data.json");
			IEnumerable<string> enumerable = from file in Directory.EnumerateFiles(directory, "*.*")
				where musicExts.Any((string x) => file.EndsWith(x, StringComparison.InvariantCultureIgnoreCase))
				select file;
			string path2 = Path.Combine(directory, "decal.png");
			PBDataJson data2 = PBDataJson.GetData(path);
			char c = (char)(97 + index);
			PersonalBoomboxPlugin.PBData pBData = new PersonalBoomboxPlugin.PBData();
			pBData.request = request;
			pBData.feedback = new PersonalBoomboxPlugin.PBData.Feedback();
			pBData.feedback.AddToMain(data2.feedback);
			pBData.name = data2.name;
			pBData.description = data2.description;
			pBData.price = data2.price;
			pBData.volume = data2.volume;
			pBData.prefab = prefabCopies[index];
			pBData.script = pBData.prefab.GetComponent<PersonalBoomboxItem>();
			pBData.script.musicAudios = new List<AudioClip>();
			pBData.color = data2.color;
			pBData.icon = CreateSprite(data2.color);
			List<Coroutine> list = new List<Coroutine>();
			foreach (string item3 in enumerable)
			{
				Coroutine item = MyOwnCoroutine.AddCoroutine(LoadAudioClip(pBData, item3));
				list.Add(item);
			}
			if (File.Exists(path2))
			{
				Coroutine item2 = MyOwnCoroutine.AddCoroutine(LoadTexture2D(pBData, path2));
				list.Add(item2);
			}
			else
			{
				pBData.feedback.AddToMain("Missing decal.png");
			}
			MyOwnCoroutine.AddCoroutine(WaitForDownloads(pBData, list));
			data.Add(pBData);
		}

		private static IEnumerator WaitForDownloads(PersonalBoomboxPlugin.PBData data, List<Coroutine> coroutines)
		{
			BoomboxesLoading++;
			yield return null;
			int i = 0;
			foreach (Coroutine coroutine in coroutines)
			{
				yield return coroutine;
				i++;
			}
			PersonalBoomboxItem script = data.script;
			int count = script.musicAudios.Count;
			script.SortAudioClips();
			script.finishedLoading = true;
			logger.LogInfo((object)$"{data.boomboxName} is fully set up with {count} songs!");
			if (count == 0)
			{
				logger.LogWarning((object)"Boomboxes with 0 songs will be skipped in the initialization process");
			}
			BoomboxesLoading--;
		}

		private static IEnumerator LoadTexture2D(PersonalBoomboxPlugin.PBData data, string path)
		{
			UnityWebRequest loader = UnityWebRequestTexture.GetTexture(path);
			loader.SendWebRequest();
			while (!loader.isDone)
			{
				yield return null;
			}
			if (loader.error != null)
			{
				string errorString2 = "Error loading decal.png. Download failed";
				logger.LogError((object)errorString2);
				logger.LogError((object)loader.error);
				data.feedback.AddToMain(errorString2.CreateError());
				yield break;
			}
			Texture2D texture = DownloadHandlerTexture.GetContent(loader);
			if ((Object)(object)texture == (Object)null)
			{
				string errorString = "Error loading decal.png. File is weird";
				data.feedback.AddToMain(errorString.CreateError());
				logger.LogError((object)errorString);
				yield break;
			}
			((Texture)texture).filterMode = (FilterMode)0;
			data.decal = texture;
			data.decalScale = GetDecalRatio(texture);
			string loadString = "Loaded decal.png";
			logger.LogInfo((object)loadString);
			data.feedback.AddToMain(loadString);
		}

		private static IEnumerator LoadAudioClip(PersonalBoomboxPlugin.PBData data, string path)
		{
			string fileName = Path.GetFileName(path);
			AudioType fileType = GetAudioType(path);
			if ((int)fileType == 0)
			{
				string errorString3 = "Error loading " + fileName + ". Unsupported file ext.";
				logger.LogError((object)errorString3);
				data.feedback.AddToSongs(errorString3.CreateError());
				yield break;
			}
			UnityWebRequest loader = UnityWebRequestMultimedia.GetAudioClip(path, GetAudioType(path));
			DownloadHandler downloadHandler = loader.downloadHandler;
			DownloadHandlerAudioClip handler = (DownloadHandlerAudioClip)(object)((downloadHandler is DownloadHandlerAudioClip) ? downloadHandler : null);
			handler.streamAudio = true;
			yield return loader.SendWebRequest();
			while (!loader.isDone)
			{
				yield return null;
			}
			if (loader.error != null)
			{
				string errorString2 = "Error loading " + fileName + ". Download failed";
				logger.LogError((object)errorString2);
				logger.LogError((object)loader.error);
				data.feedback.AddToSongs(errorString2.CreateError());
				yield break;
			}
			AudioClip clip = DownloadHandlerAudioClip.GetContent(loader);
			if ((Object)(object)clip == (Object)null || (int)clip.loadState != 2)
			{
				string errorString = "Error loading " + fileName + ". File is weird";
				logger.LogError((object)errorString);
				data.feedback.AddToSongs(errorString.CreateError());
			}
			else
			{
				data.script.AddAudioClip(clip);
				string loadString = "Loaded " + fileName;
				logger.LogInfo((object)loadString);
				data.feedback.AddToSongs(loadString);
			}
		}

		public static AudioType GetAudioType(string path)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			return (AudioType)(Path.GetExtension(path).ToLowerInvariant() switch
			{
				".mp3" => 13, 
				".ogg" => 14, 
				".wav" => 20, 
				_ => 0, 
			});
		}

		public static Vector3 GetDecalRatio(Texture2D texture)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)((Texture)texture).width / (float)((Texture)texture).height;
			float num2;
			float num3;
			if (num > 2.1014493f)
			{
				num2 = 1f;
				num3 = 2.1014493f / num;
			}
			else if (num < 2.1014493f)
			{
				num2 = num / 2.1014493f;
				num3 = 1f;
			}
			else
			{
				num2 = 1f;
				num3 = 1f;
			}
			return new Vector3(num2, num3, 1f);
		}

		public static Sprite CreateSprite(Color color)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0036: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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)
			Sprite val = boomboxSprite;
			Texture2D texture = val.texture;
			Texture2D val2 = new Texture2D(((Texture)texture).width, ((Texture)texture).height);
			Color[] pixels = texture.GetPixels();
			for (int i = 0; i < pixels.Length; i++)
			{
				ref Color reference = ref pixels[i];
				reference *= color;
			}
			val2.SetPixels(pixels);
			val2.Apply();
			return Sprite.Create(val2, val.rect, val.pivot, val.pixelsPerUnit);
		}
	}
	[Serializable]
	public class PluginConfig : SyncedInstance<PluginConfig>
	{
		public static ConfigEntry<int> maxVolumeConfig;

		public static ConfigEntry<bool> pocketCarryConfig;

		public static ConfigEntry<int> batteryConfig;

		public bool pocketCarryValue;

		public int batteryValue;

		public float maxVolumeValue => (float)maxVolumeConfig.Value * 0.01f;

		public PluginConfig(ConfigFile cfg)
		{
			InitInstance(this);
			maxVolumeConfig = ConfigBindClamp("General", "Max Volume", 100, "Max possible volume value for all p. boomboxes. From 10 to 100.", 10, 100);
			pocketCarryConfig = cfg.Bind<bool>("Network General", "Pocket Play", false, "If true, lets the p. boombox keep playing when it's put in the inventory");
			batteryConfig = ConfigBindClamp("Network General", "Battery Charge", 350, "The battery charge (in seconds) for all p. boomboxes. Clamped from 30 to 720", 30, 720);
			pocketCarryValue = pocketCarryConfig.Value;
			batteryValue = batteryConfig.Value;
			ConfigEntry<int> ConfigBindClamp(string section, string key, int defaultValue, string description, int min, int max)
			{
				ConfigEntry<int> val = cfg.Bind<int>(section, key, defaultValue, description);
				val.Value = Mathf.Clamp(val.Value, min, max);
				return val;
			}
		}

		public static void RequestSync()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<PluginConfig>.IsClient)
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(SyncedInstance<PluginConfig>.IntSize, (Allocator)2, -1);
			try
			{
				SyncedInstance<PluginConfig>.MessageManager.SendNamedMessage("PBoombox_OnRequestConfigSync", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnRequestSync(ulong clientId, FastBufferReader _)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<PluginConfig>.IsHost)
			{
				return;
			}
			SyncedInstance<PluginConfig>.logger.LogInfo((object)$"Config sync request received from client: {clientId}");
			byte[] array = SyncedInstance<PluginConfig>.SerializeToBytes(SyncedInstance<PluginConfig>.Instance);
			int num = array.Length;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(num + SyncedInstance<PluginConfig>.IntSize, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
				SyncedInstance<PluginConfig>.MessageManager.SendNamedMessage("PBoombox_OnReceieveConfigSync", clientId, val, (NetworkDelivery)3);
			}
			catch (Exception arg)
			{
				SyncedInstance<PluginConfig>.logger.LogError((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnReceiveSync(ulong _, FastBufferReader reader)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!((FastBufferReader)(ref reader)).TryBeginRead(SyncedInstance<PluginConfig>.IntSize))
			{
				SyncedInstance<PluginConfig>.logger.LogError((object)"Config sync error: Could not begin reading buffer.");
				return;
			}
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
			{
				SyncedInstance<PluginConfig>.logger.LogError((object)"Config sync error: Host could not sync.");
				return;
			}
			byte[] data = new byte[num];
			((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
			SyncedInstance<PluginConfig>.SyncInstance(data);
			SyncedInstance<PluginConfig>.logger.LogInfo((object)"Successfully synced config with host.");
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		public static void InitializeLocalPlayer()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if (SyncedInstance<PluginConfig>.IsHost)
			{
				SyncedInstance<PluginConfig>.MessageManager.RegisterNamedMessageHandler("PBoombox_OnRequestConfigSync", new HandleNamedMessageDelegate(OnRequestSync));
				SyncedInstance<PluginConfig>.Synced = true;
			}
			else
			{
				SyncedInstance<PluginConfig>.Synced = false;
				SyncedInstance<PluginConfig>.MessageManager.RegisterNamedMessageHandler("PBoombox_OnReceieveConfigSync", new HandleNamedMessageDelegate(OnReceiveSync));
				RequestSync();
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
		public static void PlayerLeave()
		{
			SyncedInstance<PluginConfig>.RevertSync();
		}
	}
	[Serializable]
	public class SyncedInstance<T>
	{
		[NonSerialized]
		protected static int IntSize = 4;

		internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;

		internal static bool IsClient => NetworkManager.Singleton.IsClient;

		internal static bool IsHost => NetworkManager.Singleton.IsHost;

		internal static ManualLogSource logger => PersonalBoomboxPlugin.Instance.logger;

		public static T Default { get; private set; }

		public static T Instance { get; private set; }

		public static bool Synced { get; internal set; }

		protected void InitInstance(T instance)
		{
			Default = instance;
			Instance = instance;
			IntSize = 4;
		}

		internal static void SyncInstance(byte[] data)
		{
			Instance = DeserializeFromBytes(data);
			Synced = true;
		}

		internal static void RevertSync()
		{
			Instance = Default;
			Synced = false;
		}

		public static byte[] SerializeToBytes(T val)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			using MemoryStream memoryStream = new MemoryStream();
			try
			{
				binaryFormatter.Serialize(memoryStream, val);
				return memoryStream.ToArray();
			}
			catch (Exception arg)
			{
				logger.LogError((object)$"Error serializing instance: {arg}");
				return null;
			}
		}

		public static T DeserializeFromBytes(byte[] data)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			using MemoryStream serializationStream = new MemoryStream(data);
			try
			{
				return (T)binaryFormatter.Deserialize(serializationStream);
			}
			catch (Exception arg)
			{
				logger.LogError((object)$"Error deserializing instance: {arg}");
				return default(T);
			}
		}
	}
	public class VolumeControl : MonoBehaviour
	{
		public float volumeModifier;

		private int volumeValue;

		public Image fillImage;

		public Image[] targetImages;

		private const float fillMin = 0.12f;

		private const float fillMax = 0.88f;

		private const float displayTime = 3f;

		private const float fadeTime = 0.25f;

		private Coroutine displayC;

		public static VolumeControl Instance { get; private set; }

		private void Awake()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			volumeValue = PlayerPrefs.GetInt("PBoombox_VolumeControlValue", 100);
			volumeModifier = (float)volumeValue * 0.01f;
			Image[] array = targetImages;
			foreach (Image val in array)
			{
				((Graphic)val).color = Color.clear;
			}
		}

		private void Update()
		{
			int num = 0;
			if (IfKeyPress(Keyboard.current.minusKey, Keyboard.current.numpadMinusKey))
			{
				num = -1;
			}
			else if (IfKeyPress(Keyboard.current.equalsKey, Keyboard.current.numpadPlusKey))
			{
				num = 1;
			}
			if (num != 0)
			{
				volumeValue = Mathf.Clamp(volumeValue + num * 10, 10, 100);
				volumeModifier = (float)volumeValue * 0.01f;
				PlayerPrefs.SetInt("PBoombox_VolumeControlValue", volumeValue);
				fillImage.fillAmount = Mathf.Lerp(0.12f, 0.88f, volumeModifier);
				Display();
			}
		}

		private bool IfKeyPress(params KeyControl[] keys)
		{
			foreach (KeyControl val in keys)
			{
				if (((ButtonControl)val).wasPressedThisFrame)
				{
					return true;
				}
			}
			return false;
		}

		private void Display()
		{
			if (displayC != null)
			{
				((MonoBehaviour)this).StopCoroutine(displayC);
			}
			displayC = ((MonoBehaviour)this).StartCoroutine(DisplayCoroutine());
		}

		private IEnumerator DisplayCoroutine()
		{
			Image[] array = targetImages;
			foreach (Image i in array)
			{
				((Graphic)i).color = Color.white;
			}
			yield return (object)new WaitForSeconds(3f);
			Image[] array2 = targetImages;
			foreach (Image j in array2)
			{
				((Graphic)j).color = Color.clear;
			}
			displayC = null;
		}
	}
	public class PersonalBoomboxItem : GrabbableObject
	{
		public AudioSource boomboxAudio;

		public List<AudioClip> musicAudios;

		public bool finishedLoading;

		public AudioClip[] stopAudios;

		public Random musicRandomizer;

		private StartOfRound playersManager;

		private RoundManager roundManager;

		public bool isPlayingMusic;

		private float noiseInterval;

		private int timesPlayedWithoutTurningOff;

		public float baseAudio;

		public bool continuePlayingOnPocket;

		public int AudioClipCount => (musicAudios != null) ? musicAudios.Count : 0;

		public void AddAudioClip(AudioClip clip)
		{
			musicAudios.Add(clip);
		}

		public void SortAudioClips()
		{
			musicAudios.Sort((AudioClip first, AudioClip second) => ((Object)first).name.CompareTo(((Object)second).name));
		}

		public override void Start()
		{
			((GrabbableObject)this).Start();
			playersManager = Object.FindObjectOfType<StartOfRound>();
			roundManager = Object.FindObjectOfType<RoundManager>();
			musicRandomizer = new Random(playersManager.randomMapSeed - 10);
			baseAudio = boomboxAudio.volume;
			HUDManager.Instance.DisplayTip("P. Boombox Volume Control", "Press +/- to change the volume of all personal boomboxes", false, true, "PBoombox_VolumeControl");
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			StartMusic(used);
		}

		private void StartMusic(bool startMusic, bool pitchDown = false)
		{
			if (startMusic && musicAudios.Count > 0)
			{
				boomboxAudio.clip = musicAudios[musicRandomizer.Next(0, musicAudios.Count)];
				boomboxAudio.pitch = 1f;
				boomboxAudio.Play();
			}
			else if (isPlayingMusic)
			{
				if (pitchDown)
				{
					((MonoBehaviour)this).StartCoroutine(musicPitchDown());
				}
				else
				{
					boomboxAudio.Stop();
					boomboxAudio.PlayOneShot(stopAudios[Random.Range(0, stopAudios.Length)]);
				}
				timesPlayedWithoutTurningOff = 0;
			}
			base.isBeingUsed = startMusic;
			isPlayingMusic = startMusic;
		}

		private IEnumerator musicPitchDown()
		{
			for (int i = 0; i < 30; i++)
			{
				yield return null;
				AudioSource obj = boomboxAudio;
				obj.pitch -= 0.033f;
				if (boomboxAudio.pitch <= 0f)
				{
					break;
				}
			}
			boomboxAudio.Stop();
			boomboxAudio.PlayOneShot(stopAudios[Random.Range(0, stopAudios.Length)]);
		}

		public override void UseUpBatteries()
		{
			((GrabbableObject)this).UseUpBatteries();
			StartMusic(startMusic: false, pitchDown: true);
		}

		public override void PocketItem()
		{
			((GrabbableObject)this).PocketItem();
			if (!continuePlayingOnPocket)
			{
				StartMusic(startMusic: false);
			}
		}

		public override void Update()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			((GrabbableObject)this).Update();
			if (isPlayingMusic)
			{
				boomboxAudio.volume = baseAudio * VolumeControl.Instance.volumeModifier;
				if (noiseInterval <= 0f)
				{
					noiseInterval = 1f;
					timesPlayedWithoutTurningOff++;
					roundManager.PlayAudibleNoise(((Component)this).transform.position, 16f, 0.9f, timesPlayedWithoutTurningOff, false, 5);
				}
				else
				{
					noiseInterval -= Time.deltaTime;
				}
				if (base.insertedBattery.charge < 0.05f)
				{
					boomboxAudio.pitch = 1f - (0.05f - base.insertedBattery.charge) * 4f;
				}
			}
		}
	}
	[BepInPlugin("ImoutoSama.PersonalBoombox", "Personal Boombox", "1.4.4")]
	[BepInProcess("Lethal Company.exe")]
	public class PersonalBoomboxPlugin : BaseUnityPlugin
	{
		public class PBData
		{
			public class Feedback
			{
				private List<string> main;

				private List<string> songs;

				public Feedback()
				{
					main = new List<string>();
					songs = new List<string>();
				}

				public void AddToMain(string text)
				{
					main.Add(text);
				}

				public void AddToSongs(string text)
				{
					songs.Add(text);
				}

				public string GetMainReport()
				{
					return string.Join("\n", main);
				}

				public string GetSongsReport()
				{
					string empty = string.Empty;
					if (songs.Count == 0)
					{
						empty += "Found 0 songs".CreateWarning();
					}
					else
					{
						string arg = ((songs.Count != 1) ? "s" : string.Empty);
						empty += $"{songs.Count} song{arg}";
						foreach (string song in songs)
						{
							empty = empty + "\n" + song;
						}
					}
					return empty;
				}
			}

			public RequestData request;

			public Feedback feedback;

			public string name;

			public string prefixName;

			public string boomboxName;

			public string description;

			public int price;

			public float volume;

			public Color color;

			public GameObject prefab;

			public PersonalBoomboxItem script;

			public Sprite icon;

			public Item item;

			public int itemIndex;

			public Texture2D decal;

			public Vector3 decalScale;

			public bool addedToTerminalKeyword;

			public bool IsFinished => Object.op_Implicit((Object)(object)script) && script.finishedLoading;

			public bool IsValid => Object.op_Implicit((Object)(object)script) && script.AudioClipCount > 0;

			public int GetPrice => request.overridePriceFlag ? request.overridePriceValue : price;
		}

		public class RequestData
		{
			public string path;

			public bool overridePriceFlag;

			public int overridePriceValue;

			public RequestData(string path)
			{
				this.path = path;
				overridePriceFlag = false;
				overridePriceValue = 0;
			}

			public RequestData(string path, bool overridePrice, int overridePriceValue)
			{
				this.path = path;
				overridePriceFlag = overridePrice;
				this.overridePriceValue = overridePriceValue;
			}
		}

		private const string modGUID = "ImoutoSama.PersonalBoombox";

		private const string modName = "Personal Boombox";

		private const string modVersion = "1.4.4";

		private readonly Harmony harmony = new Harmony("ImoutoSama.PersonalBoombox");

		internal ManualLogSource logger;

		public static List<PBData> data;

		public static List<RequestData> requests;

		public static PersonalBoomboxPlugin Instance { get; private set; }

		public static PluginConfig MyConfig { get; internal set; }

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			logger = Logger.CreateLogSource("ImoutoSama.PersonalBoombox");
			logger.LogInfo((object)"Plugin Personal Boombox has been added!");
			MyConfig = new PluginConfig(((BaseUnityPlugin)this).Config);
			harmony.PatchAll(typeof(TerminalPatch));
			harmony.PatchAll(typeof(StartOfRoundPatch));
			harmony.PatchAll(typeof(GameNetworkManagerPatch));
			harmony.PatchAll(typeof(MenuManagerPatch));
			harmony.PatchAll(typeof(PluginConfig));
			data = new List<PBData>();
			requests = new List<RequestData>();
			Assets.LoadAssetBundle();
			AddDirectory(GetLazyPath());
		}

		public string GetLazyPath()
		{
			string text = Path.Combine(Paths.PluginPath, "Your Own Personal Boomboxes");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
				Instance.logger.LogInfo((object)"Creaing 'Your Own Personal Boomboxes' folder in the plugin directory");
				CopyExampleZIP(text);
			}
			return text;
		}

		public void CopyExampleZIP(string targetPath)
		{
			string location = Assembly.GetExecutingAssembly().Location;
			string directoryName = Path.GetDirectoryName(location);
			string text = Path.Combine(directoryName, "EXAMPLE.zip");
			if (!File.Exists(text))
			{
				Instance.logger.LogError((object)"Tried to copy over EXAMPLE.zip file but could not find it");
				return;
			}
			string destFileName = Path.Combine(targetPath, "EXAMPLE.zip");
			File.Copy(text, destFileName);
		}

		public static bool ContainsPath(string path)
		{
			foreach (RequestData request in requests)
			{
				if (request.path == path)
				{
					return true;
				}
			}
			return false;
		}

		public static RequestData AddFromAssemblyDll(string dllPath)
		{
			string directoryName = Path.GetDirectoryName(dllPath);
			return AddDirectory(directoryName);
		}

		public static RequestData AddDirectory(string path)
		{
			if (ContainsPath(path))
			{
				Instance.logger.LogWarning((object)("Trying to add boombox data path that's already been added: " + path));
				return null;
			}
			Instance.logger.LogInfo((object)("Adding path to read boombox data from: " + path));
			RequestData requestData = new RequestData(path);
			requests.Add(requestData);
			return requestData;
		}

		public static string GetBonusReport()
		{
			if (data == null)
			{
				return "Data variable is null. This should literally never happen?!".CreateError();
			}
			if (data.Count == 0)
			{
				return "No boomboxes were loaded".CreateWarning();
			}
			int limitExceedCounter = Assets.LimitExceedCounter;
			if (limitExceedCounter > 0)
			{
				return $"Ignored {limitExceedCounter} boomboxes as they exceed the limit of {15}".CreateWarning();
			}
			return "Everything seems good";
		}
	}
	public static class StringUtilities
	{
		public static string CreateWarning(this string text)
		{
			return "<color=yellow>" + text + "</color>";
		}

		public static string CreateError(this string text)
		{
			return "<color=red>" + text + "</color>";
		}
	}
	public class MyOwnCoroutine : MonoBehaviour
	{
		private static MyOwnCoroutine _Instance;

		public static MyOwnCoroutine Instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)_Instance == (Object)null)
				{
					GameObject val = new GameObject("My Own Coroutine");
					_Instance = val.AddComponent<MyOwnCoroutine>();
					Object.DontDestroyOnLoad((Object)(object)val);
				}
				return _Instance;
			}
		}

		public static Coroutine AddCoroutine(IEnumerator c)
		{
			return ((MonoBehaviour)Instance).StartCoroutine(c);
		}
	}
}
namespace PersonalBoombox.Patches
{
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class GameNetworkManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void StartPatch(ref GameNetworkManager __instance)
		{
			PersonalBoomboxPlugin.Instance.logger.LogInfo((object)"Adding personal boomboxes to network list");
			NetworkManager component = ((Component)__instance).GetComponent<NetworkManager>();
			GameObject[] prefabCopies = Assets.prefabCopies;
			foreach (GameObject val in prefabCopies)
			{
				component.AddNetworkPrefab(val);
			}
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal class MenuManagerPatch
	{
		public static bool done;

		public static GameObject contentGameObject;

		public static Transform contentParent;

		public static GameObject blockPrefab;

		public static GameObject spacingPrefab;

		public static TextMeshProUGUI errorsTextMesh;

		public static bool loadedReport;

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePatch(ref MenuManager __instance)
		{
			AddReportDisplay(ref __instance);
			if (!done)
			{
				done = true;
				Assets.LoadMusicFolders();
			}
		}

		private static void AddReportDisplay(ref MenuManager __instance)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			try
			{
				Transform parent = ((Component)__instance).transform.parent;
				Transform val = parent.Find("MenuContainer").Find("MainButtons");
				GameObject gameObject = ((Component)val.Find("HostButton")).gameObject;
				GameObject val2 = Object.Instantiate<GameObject>(Assets.canvasPrefab);
				Button component = ((Component)val2.transform.Find("Button")).GetComponent<Button>();
				((UnityEventBase)component.onClick).RemoveAllListeners();
				((UnityEvent)component.onClick).AddListener(new UnityAction(ToggleReportDisplay));
				CanvasUpdateButtonVisibility canvasUpdateButtonVisibility = val2.AddComponent<CanvasUpdateButtonVisibility>();
				canvasUpdateButtonVisibility.button = ((Component)component).gameObject;
				canvasUpdateButtonVisibility.mainMenuTarget = gameObject;
				contentGameObject = ((Component)val2.transform.Find("Scroll View")).gameObject;
				contentParent = val2.transform.Find("Scroll View/Viewport/Content");
				blockPrefab = ((Component)contentParent.Find("Block")).gameObject;
				spacingPrefab = ((Component)contentParent.Find("Divider")).gameObject;
				errorsTextMesh = ((Component)contentParent.Find("Errors")).GetComponent<TextMeshProUGUI>();
				blockPrefab.SetActive(false);
				spacingPrefab.SetActive(false);
				loadedReport = false;
			}
			catch
			{
			}
		}

		private static void ToggleReportDisplay()
		{
			if (!contentGameObject.activeSelf)
			{
				if (Assets.BoomboxesLoading > 0)
				{
					((TMP_Text)errorsTextMesh).text = $"{Assets.BoomboxesLoading} boomboxes still loading... Please refresh this display in a moment";
					contentGameObject.SetActive(true);
					return;
				}
				if (!loadedReport)
				{
					SetupReportDisplay();
					loadedReport = true;
				}
				contentGameObject.SetActive(true);
			}
			else
			{
				contentGameObject.SetActive(false);
			}
		}

		private static void SetupReportDisplay()
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			foreach (PersonalBoomboxPlugin.PBData datum in PersonalBoomboxPlugin.data)
			{
				GameObject val = Object.Instantiate<GameObject>(blockPrefab, contentParent);
				Transform transform = val.transform;
				((TMP_Text)((Component)transform.Find("Title")).GetComponent<TextMeshProUGUI>()).text = "[" + datum.prefixName + "] " + datum.name;
				Transform val2 = transform.Find("Icon Area");
				((Component)val2.Find("Icon")).GetComponent<Image>().sprite = datum.icon;
				((TMP_Text)((Component)val2.Find("Text 1")).GetComponent<TextMeshProUGUI>()).text = datum.feedback.GetSongsReport();
				Transform val3 = val2.Find("Decal");
				if ((Object)(object)datum.decal == (Object)null)
				{
					((Component)val3).gameObject.SetActive(false);
				}
				else
				{
					RawImage component = ((Component)val3).GetComponent<RawImage>();
					component.texture = (Texture)(object)datum.decal;
					((Component)component).transform.localScale = datum.decalScale;
				}
				((TMP_Text)((Component)transform.Find("Errors")).GetComponent<TextMeshProUGUI>()).text = datum.feedback.GetMainReport();
				val.SetActive(true);
				GameObject val4 = Object.Instantiate<GameObject>(spacingPrefab, contentParent);
				val4.SetActive(true);
			}
			((TMP_Text)errorsTextMesh).text = PersonalBoomboxPlugin.GetBonusReport();
			((TMP_Text)errorsTextMesh).transform.SetAsLastSibling();
		}

		public static void SetContentDisplay(bool state)
		{
			if (!((Object)(object)contentGameObject == (Object)null))
			{
				contentGameObject.SetActive(state);
			}
		}

		private static void PrintTransforms(Transform parent, int counter)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			string text = new string(' ', counter);
			Canvas component = ((Component)parent).GetComponent<Canvas>();
			string text2 = (Object.op_Implicit((Object)(object)component) ? $" ({component.sortingOrder})" : string.Empty);
			PersonalBoomboxPlugin.Instance.logger.LogInfo((object)(text + ((Object)parent).name + text2));
			foreach (Transform item in parent)
			{
				Transform parent2 = item;
				PrintTransforms(parent2, counter + 1);
			}
		}
	}
	public class CanvasUpdateButtonVisibility : MonoBehaviour
	{
		public GameObject mainMenuTarget;

		public GameObject button;

		public void LateUpdate()
		{
			if (!((Object)(object)mainMenuTarget == (Object)null))
			{
				if (mainMenuTarget.activeInHierarchy)
				{
					button.SetActive(true);
					return;
				}
				button.SetActive(false);
				MenuManagerPatch.SetContentDisplay(state: false);
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		public static bool done;

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static void StartPatch(ref StartOfRound __instance)
		{
			if (done)
			{
				return;
			}
			done = true;
			PersonalBoomboxPlugin.Instance.logger.LogInfo((object)"Adding personal boomboxes to items list");
			foreach (PersonalBoomboxPlugin.PBData datum in PersonalBoomboxPlugin.data)
			{
				bool isFinished = datum.IsFinished;
				bool isValid = datum.IsValid;
				if (datum.IsFinished && datum.IsValid)
				{
					__instance.allItemsList.itemsList.Add(datum.item);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	internal class TerminalPatch
	{
		public static Item boomboxItem;

		public static GameObject boomboxPrefab;

		public static MeshFilter boomboxMeshFilter;

		public static MeshRenderer boomboxMeshRenderer;

		public static AudioSource boomboxAudioSource;

		public static BoomboxItem boomboxScript;

		public static TerminalKeyword buyKeyword;

		public static TerminalKeyword infoKeyword;

		public static CompatibleNoun buyNoun;

		public static CompatibleNoun infoNoun;

		public static int copyTerminalNodeId;

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePatch(ref Terminal __instance)
		{
			foreach (PersonalBoomboxPlugin.PBData datum in PersonalBoomboxPlugin.data)
			{
				bool isFinished = datum.IsFinished;
				bool isValid = datum.IsValid;
				if (datum.IsFinished && datum.IsValid)
				{
					AddToTerminal(ref __instance, datum);
					continue;
				}
				if (!datum.IsFinished)
				{
					PersonalBoomboxPlugin.Instance.logger.LogError((object)(datum.boomboxName + " has no script initialized or it is not done loading music"));
				}
				if (!datum.IsValid)
				{
					PersonalBoomboxPlugin.Instance.logger.LogError((object)(datum.boomboxName + " has no script initialized or it has no loaded music"));
				}
			}
			Object.Instantiate<GameObject>(Assets.volumeControlCanvasPrefab);
			((MonoBehaviour)MyOwnCoroutine.Instance).StartCoroutine(UpdateNetworkConfig());
		}

		private static IEnumerator UpdateNetworkConfig()
		{
			while (!SyncedInstance<PluginConfig>.Synced)
			{
				yield return null;
			}
			int batvalue = SyncedInstance<PluginConfig>.Instance.batteryValue;
			bool pocketvalue = SyncedInstance<PluginConfig>.Instance.pocketCarryValue;
			foreach (PersonalBoomboxPlugin.PBData d in PersonalBoomboxPlugin.data)
			{
				d.item.batteryUsage = batvalue;
				d.prefab.GetComponent<PersonalBoomboxItem>().continuePlayingOnPocket = pocketvalue;
			}
			PersonalBoomboxPlugin.Instance.logger.LogInfo((object)"Set networked config values");
		}

		private static void AddToTerminal(ref Terminal __instance, PersonalBoomboxPlugin.PBData data)
		{
			PersonalBoomboxPlugin.Instance.logger.LogInfo((object)("Adding " + data.boomboxName + " to terminal"));
			if ((Object)(object)data.item == (Object)null)
			{
				SetupPrefab(ref __instance, data);
			}
			List<Item> list = __instance.buyableItemsList.ToList();
			data.itemIndex = list.Count;
			list.Add(data.item);
			__instance.buyableItemsList = list.ToArray();
			if (!data.addedToTerminalKeyword)
			{
				AddToTerminalKeywords(ref __instance, data);
				data.addedToTerminalKeyword = true;
			}
		}

		private static void SetupPrefab(ref Terminal __instance, PersonalBoomboxPlugin.PBData data)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Expected O, but got Unknown
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)boomboxItem == (Object)null)
			{
				InitializePrefab(ref __instance);
			}
			Item val = Object.Instantiate<Item>(boomboxItem);
			GameObject prefab = data.prefab;
			PersonalBoomboxItem script = data.script;
			val.creditsWorth = data.GetPrice;
			val.spawnPrefab = prefab;
			val.itemName = data.boomboxName;
			val.itemIcon = data.icon;
			data.item = val;
			prefab.tag = boomboxPrefab.tag;
			prefab.layer = boomboxPrefab.layer;
			MeshFilter component = prefab.GetComponent<MeshFilter>();
			component.mesh = boomboxMeshFilter.mesh;
			MeshRenderer component2 = prefab.GetComponent<MeshRenderer>();
			((Renderer)component2).materials = ((Renderer)boomboxMeshRenderer).materials;
			((Renderer)component2).materials[3].color = data.color;
			((Renderer)component2).materials[1].color = DarkenColor(data.color);
			AudioSource component3 = prefab.GetComponent<AudioSource>();
			component3.volume = data.volume;
			component3.outputAudioMixerGroup = boomboxAudioSource.outputAudioMixerGroup;
			component3.SetCustomCurve((AudioSourceCurveType)0, boomboxAudioSource.GetCustomCurve((AudioSourceCurveType)0));
			component3.SetCustomCurve((AudioSourceCurveType)1, boomboxAudioSource.GetCustomCurve((AudioSourceCurveType)1));
			component3.SetCustomCurve((AudioSourceCurveType)3, boomboxAudioSource.GetCustomCurve((AudioSourceCurveType)3));
			component3.SetCustomCurve((AudioSourceCurveType)2, boomboxAudioSource.GetCustomCurve((AudioSourceCurveType)2));
			if (Object.op_Implicit((Object)(object)data.decal))
			{
				GameObject gameObject = ((Component)prefab.transform.GetChild(0)).gameObject;
				MeshRenderer component4 = gameObject.GetComponent<MeshRenderer>();
				Material material = ((Renderer)component4).material;
				material.mainTexture = (Texture)(object)data.decal;
				((Renderer)component4).material = material;
				gameObject.transform.localScale = Vector3.Scale(gameObject.transform.localScale, data.decalScale);
				gameObject.SetActive(true);
			}
			script.stopAudios = boomboxScript.stopAudios;
			((GrabbableObject)script).insertedBattery = new Battery(false, ((GrabbableObject)boomboxScript).insertedBattery.charge);
			((GrabbableObject)script).itemProperties = val;
			static Color DarkenColor(Color c)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				return new Color(c.r * 0.9f, c.g * 0.9f, c.b * 0.9f, 1f);
			}
		}

		private static void InitializePrefab(ref Terminal __instance)
		{
			List<Item> list = __instance.buyableItemsList.ToList();
			int num = -1;
			for (int i = 0; i < list.Count; i++)
			{
				Item val = list[i];
				if (val.itemName.ToLowerInvariant() == "boombox")
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				PersonalBoomboxPlugin.Instance.logger.LogError((object)"Items has no boomerbox item to copy from");
				return;
			}
			boomboxItem = list[num];
			boomboxPrefab = boomboxItem.spawnPrefab;
			boomboxMeshFilter = boomboxPrefab.GetComponent<MeshFilter>();
			boomboxMeshRenderer = boomboxPrefab.GetComponent<MeshRenderer>();
			boomboxAudioSource = boomboxPrefab.GetComponent<AudioSource>();
			boomboxScript = boomboxPrefab.GetComponent<BoomboxItem>();
		}

		private static void AddToTerminalKeywords(ref Terminal __instance, PersonalBoomboxPlugin.PBData data)
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			if ((Object)(object)buyKeyword == (Object)null)
			{
				InitializeKeyword(ref __instance);
			}
			string word = data.boomboxName.ToLowerInvariant();
			string boomboxName = data.boomboxName;
			CompatibleNoun val = CopyNoun(buyNoun);
			TerminalKeyword noun = val.noun;
			noun.word = word;
			TerminalNode result = val.result;
			result.buyItemIndex = data.itemIndex;
			result.displayText = result.displayText.Replace("boom boxes", boomboxName + " boom boxes");
			result.terminalOptions = CopyNouns(result.terminalOptions);
			TerminalNode val2 = FindNodeWithConfirm(result.terminalOptions);
			val2.buyItemIndex = data.itemIndex;
			val2.displayText = val2.displayText.Replace("boom boxes", boomboxName + " boom boxes");
			List<CompatibleNoun> list = buyKeyword.compatibleNouns.ToList();
			List<CompatibleNoun> list2 = infoKeyword.compatibleNouns.ToList();
			List<TerminalKeyword> list3 = __instance.terminalNodes.allKeywords.ToList();
			list.Add(val);
			buyKeyword.compatibleNouns = list.ToArray();
			CompatibleNoun val3 = new CompatibleNoun();
			val3.noun = val.noun;
			val3.result = CopyTerminalNode(infoNoun.result);
			val3.result.displayText = "\n" + data.description + "\n\n";
			list2.Add(val3);
			infoKeyword.compatibleNouns = list2.ToArray();
			list3.Add(noun);
			__instance.terminalNodes.allKeywords = list3.ToArray();
		}

		private static void InitializeKeyword(ref Terminal __instance)
		{
			TerminalKeyword[] allKeywords = __instance.terminalNodes.allKeywords;
			buyKeyword = ((IEnumerable<TerminalKeyword>)allKeywords).FirstOrDefault((Func<TerminalKeyword, bool>)((TerminalKeyword a) => a.word == "buy"));
			infoKeyword = ((IEnumerable<TerminalKeyword>)allKeywords).FirstOrDefault((Func<TerminalKeyword, bool>)((TerminalKeyword a) => a.word == "info"));
			buyNoun = buyKeyword.compatibleNouns.First((CompatibleNoun b) => b.noun.word == "boombox");
			infoNoun = infoKeyword.compatibleNouns.First((CompatibleNoun b) => b.noun.word == "boombox");
		}

		private static TerminalKeyword CopyTerminalKeyword(TerminalKeyword target)
		{
			TerminalKeyword val = Object.Instantiate<TerminalKeyword>(target);
			((Object)val).name = $"{((Object)val).name} {++copyTerminalNodeId}";
			return val;
		}

		private static TerminalNode CopyTerminalNode(TerminalNode target)
		{
			TerminalNode val = Object.Instantiate<TerminalNode>(target);
			((Object)val).name = $"{((Object)val).name} {++copyTerminalNodeId}";
			return val;
		}

		private static CompatibleNoun CopyNoun(CompatibleNoun target)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			CompatibleNoun val = new CompatibleNoun();
			val.noun = CopyTerminalKeyword(target.noun);
			val.result = CopyTerminalNode(target.result);
			return val;
		}

		private static CompatibleNoun[] CopyNouns(CompatibleNoun[] target)
		{
			CompatibleNoun[] array = (CompatibleNoun[])(object)new CompatibleNoun[target.Length];
			for (int i = 0; i < target.Length; i++)
			{
				array[i] = CopyNoun(target[i]);
			}
			return array;
		}

		private static TerminalNode FindNodeWithConfirm(CompatibleNoun[] nouns)
		{
			foreach (CompatibleNoun val in nouns)
			{
				if (val.noun.word.ToLowerInvariant() == "confirm")
				{
					return val.result;
				}
			}
			return null;
		}
	}
}