using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LC_HandHeldDevice.Patches;
using LethalLib.Modules;
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("LC_HandHeldDevice")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LC_HandHeldDevice")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("2e45d23a-326c-4621-879f-642402b89ccd")]
[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 LC_HandHeldDevice
{
	[BepInPlugin("Mellowdy.HandHeldMapMod", "HandHeldMapMod", "1.3.0")]
	public class HandHeldMapMod : BaseUnityPlugin
	{
		private const string modGUID = "Mellowdy.HandHeldMapMod";

		private const string modName = "HandHeldMapMod";

		private const string modVersion = "1.3.0";

		private const string assetName = "map.device";

		private const string gameObjectName = "HandHeldMapDevice.prefab";

		private readonly Harmony harmony = new Harmony("Mellowdy.HandHeldMapMod");

		public static ManualLogSource mls;

		private static HandHeldMapMod instance;

		private static string Name = "Hand-held Map";

		private static ConfigEntry<int> price;

		private static ConfigEntry<float> BatteryUsage;

		private static ConfigEntry<float> TurnOnBatteryUsage;

		private static ConfigEntry<bool> BatteryFail;

		private static ConfigEntry<float> FailureBreakPoint;

		private static ConfigEntry<float> BaseChance;

		private static ConfigEntry<float> Size;

		private static ConfigEntry<bool> Light;

		public static GameObject cameraPrefab;

		public static Material backUpMaterialOff;

		public static Material backUpMaterialOn;

		private void Awake()
		{
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
			}
			mls = Logger.CreateLogSource("Mellowdy.HandHeldMapMod");
			harmony.PatchAll();
			price = ((BaseUnityPlugin)this).Config.Bind<int>("Price", "MapPrice", 45, "Credits needed to buy the hand-held map");
			BatteryUsage = ((BaseUnityPlugin)this).Config.Bind<float>("Battery", "Battery Charge", 120f, "The amount of time in seconds the map can be active");
			TurnOnBatteryUsage = ((BaseUnityPlugin)this).Config.Bind<float>("Battery", "Turn on requirement", 0.05f, "The percent of battery that gets drained when the map gets turned on (0.1 = 10% drain each time its turned on)");
			BatteryFail = ((BaseUnityPlugin)this).Config.Bind<bool>("Battery", "Battery Failure", true, "decription");
			FailureBreakPoint = ((BaseUnityPlugin)this).Config.Bind<float>("Battery", "Battery Failure Break Point", 0.5f, "The charge breakpoint where the map will begin to glitch and fail to update as often (0.5 = map will start failing at 50% charge)");
			BaseChance = ((BaseUnityPlugin)this).Config.Bind<float>("Battery", "Base Chance", 2f, "The base chance for the map to update every second after battery failure");
			HandHeldMap.pocketTurnOff = ((BaseUnityPlugin)this).Config.Bind<bool>("Battery", "Turn off when pocketed", true, "Should the map turn off when pocketed or dropped").Value;
			Size = ((BaseUnityPlugin)this).Config.Bind<float>("Map Properties", "Size", 0.75f, "The size of the map compared to the monitor map in the ship");
			Light = ((BaseUnityPlugin)this).Config.Bind<bool>("Map Properties", "Light", false, "If the map should have nightvision like the map in the ship or not");
			HandHeldMap.BatteryUsage = BatteryUsage.Value;
			HandHeldMap.TurnOnBatteryUsage = TurnOnBatteryUsage.Value;
			HandHeldMap.BatteryFail = BatteryFail.Value;
			HandHeldMap.FailureBreakPoint = FailureBreakPoint.Value;
			HandHeldMap.BaseChance = BaseChance.Value;
			HandHeldMap.Size = Size.Value;
			HandHeldMap.LightOn = Light.Value;
			HandHeldMap.ShowEnemies = ((BaseUnityPlugin)this).Config.Bind<bool>("Visibility", "Show Enemies", true, "Should Enemies be shown").Value;
			HandHeldMap.ShowScrap = ((BaseUnityPlugin)this).Config.Bind<bool>("Visibility", "Show Scrap", true, "Should Scrap be shown").Value;
			HandHeldMap.ShowPlayers = ((BaseUnityPlugin)this).Config.Bind<bool>("Visibility", "Show Players", true, "Should Players be shown").Value;
			HandHeldMap.ShowDeadPlayers = ((BaseUnityPlugin)this).Config.Bind<bool>("Visibility", "Show Dead Players", true, "Should Dead Players be shown").Value;
			HandHeldMap.ShowDoors = ((BaseUnityPlugin)this).Config.Bind<bool>("Visibility", "Show Doors", true, "Should Doors be shown").Value;
			HandHeldMap.ShowMines = ((BaseUnityPlugin)this).Config.Bind<bool>("Visibility", "Show Mines", true, "Should Landmines be shown").Value;
			HandHeldMap.ShowTurrets = ((BaseUnityPlugin)this).Config.Bind<bool>("Visibility", "Show Turrets", true, "Should Turrets be shown").Value;
			HandHeldMap.resetTime = ((BaseUnityPlugin)this).Config.Bind<float>("Preformance", "Update Rate", 2.5f, "How often the map should update the visibility settings").Value;
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			string text = Path.Combine(directoryName, "map.device").Replace("\\", "/");
			AssetBundle val = AssetBundle.LoadFromFile(text);
			Item val2 = val.LoadAsset<Item>("Map.asset");
			GameObject val3 = val.LoadAsset<GameObject>("HandHeldMapDevice.prefab");
			cameraPrefab = val.LoadAsset<GameObject>("Camera.prefab");
			HandHeldMap.turnOn = val.LoadAsset<AudioClip>("On.wav");
			HandHeldMap.turnOff = val.LoadAsset<AudioClip>("Off.wav");
			HandHeldMap handHeldMap = val3.AddComponent<HandHeldMap>();
			((GrabbableObject)handHeldMap).originalScale = val3.transform.localScale;
			((GrabbableObject)handHeldMap).grabbable = true;
			((GrabbableObject)handHeldMap).itemProperties = val2;
			((GrabbableObject)handHeldMap).floorYRot = -1;
			val2.spawnPrefab = val3;
			NetworkPrefabs.RegisterNetworkPrefab(val2.spawnPrefab);
			Items.RegisterItem(val2);
			Items.RegisterShopItem(val2, (TerminalNode)null, (TerminalNode)null, CreateInfoNode("Hand-heldMapDevice", "Allows easy viewing of the map from anywhere."), price.Value);
			mls.LogInfo((object)"HandHeldMap mod is active");
		}

		private TerminalNode CreateInfoNode(string name, string description)
		{
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			val.clearPreviousText = true;
			((Object)val).name = name + "InfoNode";
			val.displayText = description + "\n\n";
			return val;
		}

		public static GameObject[] FindAndRemap(int layer)
		{
			GameObject[] array = Object.FindObjectsOfType<GameObject>();
			List<GameObject> list = new List<GameObject>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].layer == layer)
				{
					list.Add(array[i]);
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			return list.ToArray();
		}
	}
}
namespace LC_HandHeldDevice.Patches
{
	[HarmonyPatch(typeof(GrabbableObject))]
	internal class GrabbableObjectPatch
	{
		[HarmonyPatch("LateUpdate")]
		[HarmonyPostfix]
		private static void LootVisibilityOnMapPatch(GrabbableObject __instance)
		{
			if (!HandHeldMap.ShowScrap && (Object)(object)__instance != (Object)null && (Object)(object)__instance.radarIcon != (Object)null && (Object)(object)((Component)__instance.radarIcon).gameObject != (Object)null && HandHeldMap.currentlyShowScrap != ((Component)__instance.radarIcon).gameObject.activeSelf)
			{
				((Component)__instance.radarIcon).gameObject.SetActive(HandHeldMap.currentlyShowScrap);
			}
		}
	}
	public class HandHeldMap : GrabbableObject
	{
		private ManualCameraRenderer mcr;

		private RenderTexture renderTexture;

		public static AudioClip turnOn;

		public static AudioClip turnOff;

		public static float BatteryUsage;

		public static float TurnOnBatteryUsage;

		public static bool BatteryFail;

		public static float FailureBreakPoint;

		public static float BaseChance;

		public static float Size = 1f;

		public static bool LightOn = true;

		public static bool pocketTurnOff = true;

		public AudioSource audioSource;

		public float MaxCharge = 0f;

		private bool isOn = false;

		public static bool ShowEnemies;

		public static bool ShowScrap;

		public static bool currentlyShowScrap;

		public static bool ShowPlayers;

		public static bool ShowDeadPlayers;

		public static bool ShowDoors;

		public static bool ShowTurrets;

		public static bool ShowMines;

		public bool culled = false;

		public float cullTimer;

		public static float resetTime = 2.5f;

		public static int MaxMaps;

		public static bool ShouldUpdateOutsideLocalPlayer;

		public static int MinUpdateDistance;

		public static int activeMaps;

		private static ManualCameraRenderer originalMCR = null;

		public bool isInHand;

		public override void Start()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Expected O, but got Unknown
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Expected O, but got Unknown
			((GrabbableObject)this).Start();
			activeMaps++;
			base.insertedBattery = new Battery(false, 1f);
			MaxCharge = base.insertedBattery.charge;
			base.itemProperties.batteryUsage = BatteryUsage;
			try
			{
				if ((Object)(object)((Component)this).transform.parent == (Object)null && base.isInShipRoom && base.isInElevator && (Object)(object)StartOfRound.Instance != (Object)null && (Object)(object)StartOfRound.Instance.elevatorTransform != (Object)null)
				{
					((Component)this).transform.SetParent(StartOfRound.Instance.elevatorTransform, false);
					base.targetFloorPosition = ((Component)this).transform.localPosition - ((Component)this).transform.parent.position;
				}
				base.mainObjectRenderer = ((Component)this).GetComponent<MeshRenderer>();
				audioSource = ((Component)this).GetComponent<AudioSource>();
				GameObject val = GameObject.Find("CameraMonitorScript");
				if ((Object)(object)originalMCR == (Object)null && (Object)(object)val != (Object)null)
				{
					originalMCR = val.GetComponent<ManualCameraRenderer>();
				}
				if ((Object)(object)originalMCR == (Object)null)
				{
					originalMCR = Object.FindObjectOfType<ManualCameraRenderer>();
				}
				GameObject val2;
				if ((Object)(object)originalMCR != (Object)null && (Object)(object)originalMCR.cam != (Object)null)
				{
					val2 = ((Component)originalMCR.cam).gameObject;
				}
				else
				{
					val2 = HandHeldMapMod.cameraPrefab;
					HUDManager.Instance.DisplayTip("HandheldMap", "Failed to load proper camera for the map. Deploying safe guard. If you get this error contact the mod developer to get it fixed.", true, false, "LC_Tip1");
				}
				mcr = ((Component)this).gameObject.AddComponent<ManualCameraRenderer>();
				mcr.mesh = base.mainObjectRenderer;
				GameObject val3 = Object.Instantiate<GameObject>(val2);
				Camera component = val3.GetComponent<Camera>();
				renderTexture = new RenderTexture(((Texture)component.targetTexture).width, ((Texture)component.targetTexture).height, component.targetTexture.depth);
				mcr.mapCameraLight = val3.GetComponentInChildren<Light>();
				mcr.mapCameraAnimator = val3.GetComponentInChildren<Animator>();
				mcr.cam = component;
				mcr.mapCamera = component;
				component.targetTexture = renderTexture;
				HandHeldMapMod.mls.LogMessage((object)$"Camera size: {component.orthographicSize}");
				component.orthographicSize *= Size;
				mcr.materialIndex = 0;
				if ((Object)(object)originalMCR != (Object)null)
				{
					mcr.onScreenMat = Object.Instantiate<Material>(originalMCR.onScreenMat);
					mcr.offScreenMat = originalMCR.offScreenMat;
					mcr.shipArrowUI = originalMCR.shipArrowUI;
					mcr.shipArrowPointer = originalMCR.shipArrowPointer;
				}
				else
				{
					mcr.onScreenMat = Object.Instantiate<Material>(HandHeldMapMod.backUpMaterialOn);
					mcr.offScreenMat = HandHeldMapMod.backUpMaterialOff;
					mcr.shipArrowPointer = ((Component)this).transform;
					mcr.shipArrowUI = new GameObject();
				}
				mcr.onScreenMat.mainTexture = (Texture)(object)renderTexture;
				TurnOn(on: false);
				mcr.radarTargets.Clear();
				mcr.AddTransformAsTargetToRadar(((Component)this).transform, "You are here", true);
			}
			catch (Exception ex)
			{
				HUDManager.Instance.DisplayTip("HandheldMap", "Failed to load. " + ex, true, false, "LC_Tip1");
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public override void Update()
		{
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			((GrabbableObject)this).Update();
			if (!base.isHeld || !isInHand || !((Object)(object)base.playerHeldBy != (Object)null) || !((Object)(object)mcr != (Object)null) || !UpdateOtherMaps())
			{
				return;
			}
			if ((Object)(object)mcr.mapCameraLight != (Object)null && !((Behaviour)mcr.mapCameraLight).enabled && LightOn)
			{
				((Behaviour)mcr.mapCameraLight).enabled = LightOn;
			}
			if ((Object)(object)mcr.cam != (Object)null)
			{
				((Behaviour)mcr.cam).enabled = true;
				if (base.insertedBattery.charge / MaxCharge < FailureBreakPoint && BatteryFail)
				{
					float num = (BaseChance + base.insertedBattery.charge / MaxCharge) * Time.deltaTime;
					float num2 = Random.Range(0f, 1f);
					if (num2 <= num)
					{
						mcr.cam.Render();
					}
				}
				else
				{
					mcr.cam.Render();
				}
				if ((Object)(object)mcr.targetedPlayer != (Object)(object)base.playerHeldBy)
				{
					mcr.targetedPlayer = base.playerHeldBy;
				}
			}
			if (cullTimer <= 0f)
			{
				cullTimer = resetTime;
				bool flag = culled;
				PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
				if (localPlayerController.isInElevator || localPlayerController.isInHangarShipRoom || Vector3.Distance(((Component)localPlayerController).transform.position, StartOfRound.Instance.elevatorTransform.position) < 10f)
				{
					culled = false;
				}
				else
				{
					culled = true;
				}
				CullRelevantGameObjects(!culled);
			}
			else
			{
				cullTimer -= Time.deltaTime;
			}
		}

		public bool UpdateOtherMaps()
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			return (Object)(object)base.playerHeldBy == (Object)(object)localPlayerController;
		}

		public void TurnOn(bool on)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			bool flag = isOn != on;
			isOn = on;
			base.isBeingUsed = on;
			mcr.SwitchScreenOn(on);
			if (!flag)
			{
				return;
			}
			if (on)
			{
				audioSource.PlayOneShot(turnOn);
				if (base.insertedBattery.charge != 1f)
				{
					((MonoBehaviour)this).StartCoroutine((IEnumerator)Drain(1f));
				}
			}
			else
			{
				audioSource.PlayOneShot(turnOff);
			}
			RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, 10f, 0.65f, 0, base.isInElevator && StartOfRound.Instance.hangarDoorsClosed, 0);
		}

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

		public override void UseUpBatteries()
		{
			((GrabbableObject)this).UseUpBatteries();
			TurnOn(on: false);
		}

		public override void GrabItem()
		{
			mcr.targetedPlayer = base.playerHeldBy;
			((GrabbableObject)this).GrabItem();
			isInHand = true;
			((Behaviour)mcr).enabled = true;
			((Behaviour)mcr.cam).enabled = true;
		}

		public override void EquipItem()
		{
			((GrabbableObject)this).EquipItem();
			isInHand = true;
		}

		public override void PocketItem()
		{
			((GrabbableObject)this).PocketItem();
			if (pocketTurnOff)
			{
				TurnOn(on: false);
			}
			isInHand = false;
		}

		public override void DiscardItem()
		{
			((GrabbableObject)this).DiscardItem();
			if (pocketTurnOff)
			{
				TurnOn(on: false);
			}
			isInHand = false;
			((Behaviour)mcr).enabled = false;
			((Behaviour)mcr.cam).enabled = false;
		}

		public override void ChargeBatteries()
		{
			((GrabbableObject)this).ChargeBatteries();
			MaxCharge = base.insertedBattery.charge;
		}

		public IEnumerator<WaitForEndOfFrame> Drain(float Duration)
		{
			float t = 0f;
			while (t < Duration)
			{
				base.insertedBattery.charge = Mathf.Max(base.insertedBattery.charge - MaxCharge * TurnOnBatteryUsage * Time.deltaTime / Duration, 0f);
				t += Time.deltaTime;
				yield return new WaitForEndOfFrame();
			}
		}

		public override void OnDestroy()
		{
			((NetworkBehaviour)this).OnDestroy();
			renderTexture.Release();
			Object.Destroy((Object)(object)((Component)mcr.cam).gameObject);
			activeMaps--;
		}

		public static void CullRelevantGameObjects(bool cull)
		{
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			if (!ShowEnemies)
			{
				EnemyAI[] array = Object.FindObjectsOfType<EnemyAI>(true);
				EnemyAI[] array2 = array;
				foreach (EnemyAI val in array2)
				{
					GameObject val2 = ((!((Object)(object)((Component)val).transform.parent != (Object)null)) ? FindMapDot(((Component)val).gameObject) : FindMapDot(((Component)((Component)val).transform.parent).gameObject));
					if ((Object)(object)val2 != (Object)null)
					{
						val2.SetActive(cull);
					}
				}
			}
			if (!ShowScrap)
			{
				currentlyShowScrap = cull;
			}
			if (!ShowPlayers)
			{
				PlayerControllerB[] array3 = Object.FindObjectsOfType<PlayerControllerB>(true);
				PlayerControllerB[] array4 = array3;
				foreach (PlayerControllerB val3 in array4)
				{
					Animator mapRadarDotAnimator = val3.mapRadarDotAnimator;
					if ((Object)(object)mapRadarDotAnimator != (Object)null)
					{
						((Component)mapRadarDotAnimator).gameObject.SetActive(cull);
					}
				}
			}
			if (!ShowDeadPlayers)
			{
				DeadBodyInfo[] array5 = Object.FindObjectsOfType<DeadBodyInfo>(true);
				DeadBodyInfo[] array6 = array5;
				foreach (DeadBodyInfo val4 in array6)
				{
					((Component)val4.radarDot).gameObject.SetActive(cull);
				}
			}
			if (!ShowDoors)
			{
				GameObject val5 = GameObject.Find("Systems/GameSystems/ItemSystems/MapScreenUIWorldSpace");
				if ((Object)(object)val5 != (Object)null)
				{
					foreach (Transform item in val5.transform)
					{
						Transform val6 = item;
						((Component)val6).gameObject.SetActive(cull);
					}
				}
			}
			if (!ShowMines)
			{
				Landmine[] array7 = Object.FindObjectsOfType<Landmine>(true);
				Landmine[] array8 = array7;
				foreach (Landmine val7 in array8)
				{
					Transform val8 = ((Component)val7).transform.parent.Find("ScanSphere");
					if ((Object)(object)val8 != (Object)null)
					{
						((Component)val8).gameObject.SetActive(cull);
					}
				}
			}
			if (ShowTurrets)
			{
				return;
			}
			Turret[] array9 = Object.FindObjectsOfType<Turret>(true);
			Turret[] array10 = array9;
			foreach (Turret val9 in array10)
			{
				foreach (Transform item2 in ((Component)val9).transform.parent.Find("MeshContainer").Find("RotatingRodContainer"))
				{
					Transform val10 = item2;
					if (((Object)val10).name.StartsWith("Plane"))
					{
						((Component)val10).gameObject.SetActive(cull);
					}
				}
			}
		}

		private static GameObject FindMapDot(GameObject enemyObject, bool isModel = false)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			foreach (Transform item in enemyObject.transform)
			{
				Transform val = item;
				if (((Object)val).name.StartsWith("MapDot"))
				{
					return ((Component)val).gameObject;
				}
				if ((!isModel && ((Object)val).name.EndsWith("Model")) || ((Object)val).name.EndsWith("ModelContainer"))
				{
					GameObject val2 = FindMapDot(((Component)val).gameObject);
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
				}
			}
			return null;
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using On;
using Unity.Netcode;
using UnityEngine;

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LethalPresents
{
	[BepInPlugin("LethalPresents", "LethalPresents", "1.0.4")]
	public class LethalPresentsPlugin : BaseUnityPlugin
	{
		public static ManualLogSource mls;

		private static int spawnChance = 5;

		private static string[] disabledEnemies = new string[0];

		private static bool IsAllowlist = false;

		private static bool ShouldSpawnMines = false;

		private static bool ShouldSpawnTurrets = false;

		private static bool ShouldSpawnBees = false;

		private static bool isHost => ((NetworkBehaviour)RoundManager.Instance).NetworkManager.IsHost;

		private static SelectableLevel currentLevel => RoundManager.Instance.currentLevel;

		internal static T GetPrivateField<T>(object instance, string fieldName)
		{
			FieldInfo field = instance.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
			return (T)field.GetValue(instance);
		}

		private void Awake()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			mls = Logger.CreateLogSource("LethalPresents");
			mls.LogInfo((object)"Plugin LethalPresents is loaded!");
			loadConfig();
			RoundManager.AdvanceHourAndSpawnNewBatchOfEnemies += new hook_AdvanceHourAndSpawnNewBatchOfEnemies(updateCurrentLevelInfo);
			GiftBoxItem.OpenGiftBoxServerRpc += new hook_OpenGiftBoxServerRpc(spawnRandomEntity);
		}

		private void updateCurrentLevelInfo(orig_AdvanceHourAndSpawnNewBatchOfEnemies orig, RoundManager self)
		{
			orig.Invoke(self);
			mls.LogInfo((object)"List of spawnable enemies (inside):");
			currentLevel.Enemies.ForEach(delegate(SpawnableEnemyWithRarity e)
			{
				mls.LogInfo((object)((Object)e.enemyType).name);
			});
			mls.LogInfo((object)"List of spawnable enemies (outside):");
			currentLevel.OutsideEnemies.ForEach(delegate(SpawnableEnemyWithRarity e)
			{
				mls.LogInfo((object)((Object)e.enemyType).name);
			});
		}

		private void loadConfig()
		{
			spawnChance = ((BaseUnityPlugin)this).Config.Bind<int>("General", "SpawnChance", 5, "Chance of spawning an enemy when opening a present [0-100]").Value;
			disabledEnemies = ((BaseUnityPlugin)this).Config.Bind<string>("General", "EnemyBlocklist", "", "Enemy blocklist separated by , and without whitespaces").Value.Split(",");
			IsAllowlist = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "IsAllowlist", false, "Turns blocklist into allowlist, blocklist must contain at least one inside and one outside enemy, use at your own risk").Value;
			ShouldSpawnMines = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShouldSpawnMines", true, "Add mines to the spawn pool").Value;
			ShouldSpawnTurrets = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShouldSpawnTurrets", true, "Add turrets to the spawn pool").Value;
			if (IsAllowlist)
			{
				mls.LogInfo((object)"Only following enemies can spawn from the gift:");
			}
			else
			{
				mls.LogInfo((object)"Following enemies wont be spawned from the gift:");
			}
			string[] array = disabledEnemies;
			foreach (string text in array)
			{
				mls.LogInfo((object)text);
			}
		}

		private void spawnRandomEntity(orig_OpenGiftBoxServerRpc orig, GiftBoxItem self)
		{
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)self).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				orig.Invoke(self);
				return;
			}
			int privateField = GetPrivateField<int>(self, "__rpc_exec_stage");
			mls.LogInfo((object)("IsServer:" + networkManager.IsServer + " IsHost:" + networkManager.IsHost + " __rpc_exec_stage:" + privateField));
			if (privateField != 1 || !isHost)
			{
				orig.Invoke(self);
				return;
			}
			int num = Random.Range(1, 100);
			mls.LogInfo((object)("Player's fortune:" + num));
			if (num >= spawnChance)
			{
				orig.Invoke(self);
				return;
			}
			chooseAndSpawnEnemy(((GrabbableObject)self).isInFactory, ((Component)self).transform.position, ((Component)self.previousPlayerHeldBy).transform.position);
			orig.Invoke(self);
		}

		private static void chooseAndSpawnEnemy(bool inside, Vector3 pos, Vector3 player_pos)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource obj = mls;
			Vector3 val = player_pos;
			obj.LogInfo((object)("Player pos " + ((object)(Vector3)(ref val)).ToString()));
			List<SpawnableEnemyWithRarity> list = currentLevel.Enemies.Where((SpawnableEnemyWithRarity e) => disabledEnemies.Contains(((Object)e.enemyType).name) ? IsAllowlist : (!IsAllowlist)).ToList();
			List<SpawnableEnemyWithRarity> list2 = currentLevel.OutsideEnemies.Where((SpawnableEnemyWithRarity e) => disabledEnemies.Contains(((Object)e.enemyType).name) ? IsAllowlist : (!IsAllowlist)).ToList();
			int num = Random.Range(1, 2 + (list2.Count + list.Count) / 2);
			if (num == 2 && !ShouldSpawnMines)
			{
				num = 1;
			}
			if (num == 1 && !ShouldSpawnTurrets)
			{
				num = 2;
			}
			if (num == 2 && !ShouldSpawnMines)
			{
				num = 3;
			}
			switch (num)
			{
			case 1:
			{
				SpawnableMapObject[] spawnableMapObjects2 = currentLevel.spawnableMapObjects;
				foreach (SpawnableMapObject val4 in spawnableMapObjects2)
				{
					if (!((Object)(object)val4.prefabToSpawn.GetComponentInChildren<Turret>() == (Object)null))
					{
						pos -= Vector3.up * 1.8f;
						GameObject val5 = Object.Instantiate<GameObject>(val4.prefabToSpawn, pos, Quaternion.identity);
						val5.transform.position = pos;
						Transform transform = val5.transform;
						val = player_pos - pos;
						transform.forward = ((Vector3)(ref val)).normalized;
						val5.GetComponent<NetworkObject>().Spawn(true);
						ManualLogSource obj3 = mls;
						val = pos;
						obj3.LogInfo((object)("Tried spawning a turret at " + ((object)(Vector3)(ref val)).ToString()));
						break;
					}
				}
				return;
			}
			case 2:
			{
				SpawnableMapObject[] spawnableMapObjects = currentLevel.spawnableMapObjects;
				foreach (SpawnableMapObject val2 in spawnableMapObjects)
				{
					if (!((Object)(object)val2.prefabToSpawn.GetComponentInChildren<Landmine>() == (Object)null))
					{
						pos -= Vector3.up * 1.8f;
						GameObject val3 = Object.Instantiate<GameObject>(val2.prefabToSpawn, pos, Quaternion.identity);
						val3.transform.position = pos;
						val3.transform.forward = new Vector3(1f, 0f, 0f);
						val3.GetComponent<NetworkObject>().Spawn(true);
						ManualLogSource obj2 = mls;
						val = pos;
						obj2.LogInfo((object)("Tried spawning a mine at " + ((object)(Vector3)(ref val)).ToString()));
						break;
					}
				}
				return;
			}
			}
			SpawnableEnemyWithRarity val6;
			if (inside)
			{
				if (list.Count < 1)
				{
					mls.LogInfo((object)"Cant spawn enemy - no other enemies present to copy from");
					return;
				}
				val6 = list[Random.Range(0, list.Count - 1)];
			}
			else
			{
				if (list2.Count < 1)
				{
					mls.LogInfo((object)"Cant spawn enemy - no other enemies present to copy from");
					return;
				}
				val6 = list2[Random.Range(0, list2.Count - 1)];
			}
			pos += Vector3.up * 0.25f;
			ManualLogSource obj4 = mls;
			string enemyName = val6.enemyType.enemyName;
			val = pos;
			obj4.LogInfo((object)("Spawning " + enemyName + " at " + ((object)(Vector3)(ref val)).ToString()));
			SpawnEnemy(val6, pos, 0f);
		}

		private static void SpawnEnemy(SpawnableEnemyWithRarity enemy, Vector3 pos, float rot)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			RoundManager.Instance.SpawnEnemyGameObject(pos, rot, -1, enemy.enemyType);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "LethalPresents";

		public const string PLUGIN_NAME = "LethalPresents";

		public const string PLUGIN_VERSION = "1.0.4";
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using LethalLib.Modules;
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("LootableMusicTapes")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LootableMusicTapes")]
[assembly: AssemblyCopyright("Copyright c  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("f2b95627-162b-4df4-a33a-0bd7a6bb221b")]
[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")]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace LootableMusicTapes;

[BepInPlugin("ohotdog.lootablemusictapes", "Lootable Music Tapes", "1.0.1")]
public class LootableMusicTapesBase : BaseUnityPlugin
{
	private const string modGUID = "ohotdog.lootablemusictapes";

	private const string modName = "Lootable Music Tapes";

	private const string modVersion = "1.0.1";

	private static string bundlePath = "";

	private readonly Harmony harmony = new Harmony("ohotdog.lootablemusictapes");

	private static LootableMusicTapesBase Instance;

	internal ManualLogSource logSource;

	public static GameObject cassettePlayerPrefab;

	private void Awake()
	{
		if ((Object)(object)Instance == (Object)null)
		{
			Instance = this;
		}
		logSource = Logger.CreateLogSource("ohotdog.lootablemusictapes");
		bundlePath = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "cassetteitem");
		Assets.LoadAssetBundle(bundlePath);
		AssetBundle bundle = Assets.GetBundle();
		Item val = bundle.LoadAsset<Item>("cassetteplayeritem");
		CassettePlayer cassettePlayer = val.spawnPrefab.AddComponent<CassettePlayer>();
		((GrabbableObject)cassettePlayer).itemProperties = val;
		((GrabbableObject)cassettePlayer).itemProperties.creditsWorth = 35;
		((GrabbableObject)cassettePlayer).itemProperties.minValue = 25;
		((GrabbableObject)cassettePlayer).itemProperties.maxValue = 50;
		((GrabbableObject)cassettePlayer).itemProperties.highestSalePercentage = 60;
		cassettePlayer.insert = bundle.LoadAsset<AudioClip>("walkman-insert");
		cassettePlayer.eject = bundle.LoadAsset<AudioClip>("walkman-eject");
		cassettePlayer.play = bundle.LoadAsset<AudioClip>("walkman-play");
		cassettePlayer.stop = bundle.LoadAsset<AudioClip>("walkman-stop");
		cassettePlayer.close = bundle.LoadAsset<AudioClip>("walkman-close");
		CassettePlayer.cassetteSongs = new List<AudioClip>();
		CreateCassetteItem(0, bundle, "cassettenazareitem", 973, "na-zare", 65, 20, 30, (LevelTypes)2);
		CreateCassetteItem(1, bundle, "cassettelastchristmasitem", 974, "lastchristmas", 60, 20, 30, (LevelTypes)510);
		CreateCassetteItem(2, bundle, "cassettestayinaliveitem", 975, "stayinalive", 61, 25, 35, (LevelTypes)8);
		CreateCassetteItem(3, bundle, "cassettemammasdontitem", 976, "mammasdont", 68, 25, 35, (LevelTypes)4);
		CreateCassetteItem(4, bundle, "cassetteshadilayitem", 977, "shadilay", 67, 30, 40, (LevelTypes)32);
		CreateCassetteItem(5, bundle, "cassettehounddogitem", 978, "hounddog", 54, 35, 45, (LevelTypes)4);
		CreateCassetteItem(6, bundle, "cassettewhitechristmasitem", 979, "whitechristmas", 52, 40, 50, (LevelTypes)256);
		CreateCassetteItem(7, bundle, "cassettesleepwalkitem", 980, "sleepwalk", 51, 45, 55, (LevelTypes)16);
		CreateCassetteItem(8, bundle, "cassetteoutoftouchitem", 981, "outoftouch", 45, 50, 60, (LevelTypes)2);
		CreateCassetteItem(9, bundle, "cassettefeliznavidaditem", 982, "feliznavidad", 43, 55, 65, (LevelTypes)64);
		CreateCassetteItem(10, bundle, "cassetteitsrainingmenitem", 983, "itsrainingmen", 48, 60, 70, (LevelTypes)8);
		CreateCassetteItem(11, bundle, "cassettetimeaftertimeitem", 984, "timeaftertime", 45, 65, 75, (LevelTypes)510);
		CreateCassetteItem(12, bundle, "cassettelivinonaprayeritem", 985, "livinonaprayer", 43, 70, 80, (LevelTypes)32);
		CreateCassetteItem(13, bundle, "cassetteheartacheitem", 986, "heartache", 41, 75, 85, (LevelTypes)16);
		CreateCassetteItem(14, bundle, "cassettekletkaitem", 987, "kletka", 40, 80, 90, (LevelTypes)64);
		CreateCassetteItem(15, bundle, "cassettecountryroadsitem", 988, "countryroads", 35, 85, 95, (LevelTypes)4);
		CreateCassetteItem(16, bundle, "cassettetotaleclipseitem", 989, "totaleclipse", 27, 90, 100, (LevelTypes)8);
		CreateCassetteItem(17, bundle, "cassetteineedaheroitem", 990, "ineedahero", 27, 90, 100, (LevelTypes)8);
		CreateCassetteItem(18, bundle, "cassettedangerzoneitem", 991, "dangerzone", 23, 95, 115, (LevelTypes)256);
		CreateCassetteItem(19, bundle, "cassetteroundaboutitem", 992, "roundabout", 14, 100, 110, (LevelTypes)2);
		CreateCassetteItem(20, bundle, "cassettekonchitsyaitem", 993, "konchitsya", 8, 110, 130, (LevelTypes)510);
		CreateCassetteItem(21, bundle, "cassetteworstbanditem", 994, "worstband", 40, 25, 35, (LevelTypes)510);
		CreateCassetteItem(22, bundle, "cassettemrsquareitem", 995, "mrsquare", 30, 79, 89, (LevelTypes)4);
		Items.RegisterShopItem(val, 35);
		cassettePlayerPrefab = val.spawnPrefab;
		Type[] types = Assembly.GetExecutingAssembly().GetTypes();
		Type[] array = types;
		foreach (Type type in array)
		{
			MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo[] array2 = methods;
			foreach (MethodInfo methodInfo in array2)
			{
				object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
				if (customAttributes.Length != 0)
				{
					methodInfo.Invoke(null, null);
				}
			}
		}
		NetworkPrefabs.RegisterNetworkPrefab(cassettePlayerPrefab);
		harmony.PatchAll();
		logSource.LogInfo((object)"Lootable Music Tapes started successfully!");
	}

	public static void AddNewSong(AudioClip songClip)
	{
		CassettePlayer.cassetteSongs.Add(songClip);
	}

	public void CreateCassetteItem(int songIndex, AssetBundle assetBundle, string itemAssetName, int cassetteItemId, string assetSongName, int rarity, int minValue, int maxValue, LevelTypes levelType)
	{
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		Item val = assetBundle.LoadAsset<Item>(itemAssetName);
		val.itemId = cassetteItemId;
		Cassette cassette = val.spawnPrefab.AddComponent<Cassette>();
		val.spawnPrefab.GetComponentInChildren<ScanNodeProperties>().minRange = 2;
		val.spawnPrefab.GetComponentInChildren<ScanNodeProperties>().maxRange = 15;
		val.spawnPrefab.GetComponentInChildren<ScanNodeProperties>().requiresLineOfSight = true;
		val.spawnPrefab.GetComponentInChildren<ScanNodeProperties>().nodeType = 2;
		val.spawnPrefab.GetComponentInChildren<ScanNodeProperties>().creatureScanID = -1;
		string subText = val.spawnPrefab.GetComponentInChildren<ScanNodeProperties>().subText;
		((GrabbableObject)cassette).itemProperties = val;
		cassette.songIndex = songIndex;
		AddNewSong(assetBundle.LoadAsset<AudioClip>(assetSongName));
		cassette.cassetteName = subText;
		((GrabbableObject)cassette).itemProperties.itemName = "Cassette - " + subText;
		((GrabbableObject)cassette).itemProperties.minValue = minValue;
		((GrabbableObject)cassette).itemProperties.maxValue = maxValue;
		((GrabbableObject)cassette).itemProperties.isScrap = true;
		((GrabbableObject)cassette).itemProperties.isConductiveMetal = false;
		((GrabbableObject)cassette).itemProperties.creditsWorth = maxValue - 5;
		((GrabbableObject)cassette).scrapValue = maxValue - 5;
		NetworkPrefabs.RegisterNetworkPrefab(val.spawnPrefab);
		Items.RegisterScrap(val, rarity, levelType);
	}
}
public class Cassette : GrabbableObject
{
	private AudioSource audioSource;

	public string cassetteName;

	public int songIndex;

	public void Awake()
	{
		audioSource = ((Component)this).GetComponent<AudioSource>();
		base.grabbable = true;
		base.grabbableToEnemies = true;
		base.mainObjectRenderer = ((Component)this).GetComponent<MeshRenderer>();
		base.itemProperties.toolTips = new string[2] { "Insert into Walkman : [LMB]", "Inspect : [Z]" };
		base.customGrabTooltip = "Grab " + base.itemProperties.itemName + " : [E]";
		Debug.Log((object)("Cassette " + cassetteName + " has spawned!"));
	}

	public override void ItemActivate(bool used, bool buttonDown = true)
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)base.playerHeldBy == (Object)null || !((NetworkBehaviour)this).IsOwner)
		{
			return;
		}
		Debug.Log((object)"Casting ray");
		RaycastHit val = default(RaycastHit);
		if (Physics.Raycast(new Ray(((Component)base.playerHeldBy.gameplayCamera).transform.position, ((Component)base.playerHeldBy.gameplayCamera).transform.forward), ref val, 5f, 832) && ((Component)((RaycastHit)(ref val)).collider).gameObject.layer != 8 && ((Component)((RaycastHit)(ref val)).collider).tag == "PhysicsProp")
		{
			CassettePlayer component = ((Component)((RaycastHit)(ref val)).transform).GetComponent<CassettePlayer>();
			Debug.Log((object)((object)(RaycastHit)(ref val)).ToString());
			Debug.Log((object)((Object)((RaycastHit)(ref val)).transform).name);
			if ((Object)(object)component != (Object)null && !component.insertedCassette)
			{
				component.InsertCassetteSyncWithServer(songIndex);
				base.playerHeldBy.DiscardHeldObject(true, ((Component)component).GetComponent<NetworkObject>(), default(Vector3), true);
			}
		}
		((GrabbableObject)this).ItemActivate(used, buttonDown);
	}

	public override void GrabItem()
	{
		((GrabbableObject)this).GrabItem();
		if ((Object)(object)((Component)this).transform != (Object)null && (Object)(object)((Component)this).transform.parent != (Object)null && (Object)(object)((Component)((Component)this).transform.parent).GetComponent<CassettePlayer>() != (Object)null)
		{
			((Component)((Component)this).transform.parent).GetComponent<CassettePlayer>().EjectCassetteSyncWithServer();
			((Component)this).transform.SetParent(StartOfRound.Instance.propsContainer, true);
		}
	}

	public override void PocketItem()
	{
		((GrabbableObject)this).PocketItem();
		((Component)this).gameObject.SetActive(false);
	}

	public override void EquipItem()
	{
		((GrabbableObject)this).EquipItem();
		((Component)this).gameObject.SetActive(true);
	}

	protected override void __initializeVariables()
	{
		((GrabbableObject)this).__initializeVariables();
	}

	protected internal override string __getTypeName()
	{
		return "Cassette";
	}
}
public class CassettePlayer : GrabbableObject
{
	private AudioSource audioSource;

	public AudioClip song;

	public AudioClip insert;

	public AudioClip eject;

	public AudioClip stop;

	public AudioClip play;

	public AudioClip close;

	public bool insertedCassette;

	private RoundManager roundManager;

	private StartOfRound playersManager;

	public bool isPlayingMusic;

	private int timesPlayedWithoutTurningOff;

	private float noiseInterval;

	private bool isPlayPressed = false;

	public static List<AudioClip> cassetteSongs;

	public NetworkVariable<int> audioIndex = new NetworkVariable<int>(-1, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)1);

	public int _audioIndex = -1;

	public static event Action<string> CassetteEvent;

	public override void OnNetworkSpawn()
	{
		_audioIndex = -1;
		NetworkVariable<int> obj = audioIndex;
		obj.OnValueChanged = (OnValueChangedDelegate<int>)(object)Delegate.Combine((Delegate?)(object)obj.OnValueChanged, (Delegate?)(object)new OnValueChangedDelegate<int>(OnAudioIndexChanged));
		((NetworkBehaviour)this).OnNetworkSpawn();
	}

	public override void OnNetworkDespawn()
	{
		((NetworkBehaviour)this).OnNetworkDespawn();
		NetworkVariable<int> obj = audioIndex;
		obj.OnValueChanged = (OnValueChangedDelegate<int>)(object)Delegate.Remove((Delegate?)(object)obj.OnValueChanged, (Delegate?)(object)new OnValueChangedDelegate<int>(OnAudioIndexChanged));
	}

	private void OnAudioIndexChanged(int previous, int current)
	{
		_audioIndex = current;
		if (_audioIndex != -1)
		{
			song = cassetteSongs[_audioIndex];
			audioSource.PlayOneShot(insert);
		}
		else
		{
			song = null;
			audioSource.Stop();
			audioSource.PlayOneShot(stop);
		}
	}

	public override void Start()
	{
		((GrabbableObject)this).Start();
		insertedCassette = false;
		audioSource = ((Component)this).GetComponent<AudioSource>();
		base.grabbable = true;
		base.grabbableToEnemies = true;
		base.mainObjectRenderer = ((Component)this).GetComponent<MeshRenderer>();
		base.useCooldown = 0.5f;
		base.itemProperties.requiresBattery = false;
		playersManager = Object.FindObjectOfType<StartOfRound>();
		roundManager = Object.FindObjectOfType<RoundManager>();
		base.customGrabTooltip = "Grab Walkman : [E]";
	}

	private void InsertCassette(int songIndex)
	{
		if (!insertedCassette)
		{
			insertedCassette = true;
			_audioIndex = songIndex;
			if (songIndex != -1)
			{
				song = cassetteSongs[_audioIndex];
			}
			if (((NetworkBehaviour)this).IsOwner)
			{
				audioIndex.Value = songIndex;
			}
		}
	}

	public void InsertCassetteSyncWithServer(int songIndex)
	{
		if (!insertedCassette)
		{
			InsertCassette(songIndex);
			InsertCassetteServerRpc(songIndex);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void InsertCassetteServerRpc(int songIndex)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: 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)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(720241444u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, songIndex);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 720241444u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				InsertCassetteClientRpc(songIndex);
			}
		}
	}

	[ClientRpc]
	public void InsertCassetteClientRpc(int songIndex)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: 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)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3622550067u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, songIndex);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3622550067u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				InsertCassette(songIndex);
			}
		}
	}

	private void EjectCassette()
	{
		if (insertedCassette)
		{
			StartMusic(startMusic: false);
			insertedCassette = false;
			_audioIndex = -1;
			if (((NetworkBehaviour)this).IsOwner)
			{
				audioIndex.Value = -1;
			}
			song = null;
		}
	}

	public void EjectCassetteSyncWithServer()
	{
		if (insertedCassette)
		{
			EjectCassette();
			EjectCassetteServerRpc();
		}
	}

	[ServerRpc(RequireOwnership = false)]
	public void EjectCassetteServerRpc()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: 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)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1658162722u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1658162722u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				EjectCassetteClientRpc();
			}
		}
	}

	[ClientRpc]
	public void EjectCassetteClientRpc()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: 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)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3164336292u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3164336292u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				EjectCassette();
			}
		}
	}

	public override void ItemActivate(bool used, bool buttonDown = true)
	{
		((GrabbableObject)this).ItemActivate(used, buttonDown);
		if (!isPlayingMusic)
		{
			StartMusic(startMusic: true);
		}
		else
		{
			StartMusic(startMusic: false);
		}
	}

	public void StartMusic(bool startMusic, bool pitchDown = false)
	{
		if (!insertedCassette)
		{
			if (isPlayPressed)
			{
				audioSource.PlayOneShot(play);
				isPlayPressed = false;
			}
			else
			{
				audioSource.PlayOneShot(stop);
				isPlayPressed = true;
			}
			return;
		}
		if (startMusic && !isPlayingMusic)
		{
			audioSource.PlayOneShot(play);
			audioSource.PlayOneShot(song);
		}
		else if (isPlayingMusic)
		{
			audioSource.Stop();
			audioSource.PlayOneShot(stop);
			timesPlayedWithoutTurningOff = 0;
		}
		base.isBeingUsed = startMusic;
		isPlayingMusic = startMusic;
	}

	public override void Update()
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		((GrabbableObject)this).Update();
		if (isPlayingMusic)
		{
			if (noiseInterval <= 0f)
			{
				noiseInterval = 1f;
				timesPlayedWithoutTurningOff++;
				roundManager.PlayAudibleNoise(((Component)this).transform.position, 16f, 0.9f, timesPlayedWithoutTurningOff, false, 5);
			}
			else
			{
				noiseInterval -= Time.deltaTime;
			}
		}
	}

	protected override void __initializeVariables()
	{
		if (audioIndex == null)
		{
			throw new Exception("CassettePlayer.audioIndex cannot be null. All NetworkVariableBase instances must be initialized.");
		}
		((NetworkVariableBase)audioIndex).Initialize((NetworkBehaviour)(object)this);
		((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)audioIndex, "audioIndex");
		((NetworkBehaviour)this).NetworkVariableFields.Add((NetworkVariableBase)(object)audioIndex);
		((GrabbableObject)this).__initializeVariables();
	}

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_CassettePlayer()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Expected O, but got Unknown
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		NetworkManager.__rpc_func_table.Add(720241444u, new RpcReceiveHandler(__rpc_handler_720241444));
		NetworkManager.__rpc_func_table.Add(3622550067u, new RpcReceiveHandler(__rpc_handler_3622550067));
		NetworkManager.__rpc_func_table.Add(1658162722u, new RpcReceiveHandler(__rpc_handler_1658162722));
		NetworkManager.__rpc_func_table.Add(3164336292u, new RpcReceiveHandler(__rpc_handler_3164336292));
	}

	private static void __rpc_handler_720241444(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int songIndex = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref songIndex);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((CassettePlayer)(object)target).InsertCassetteServerRpc(songIndex);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3622550067(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			int songIndex = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref songIndex);
			target.__rpc_exec_stage = (__RpcExecStage)2;
			((CassettePlayer)(object)target).InsertCassetteClientRpc(songIndex);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1658162722(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((CassettePlayer)(object)target).EjectCassetteServerRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3164336292(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = target.NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			target.__rpc_exec_stage = (__RpcExecStage)2;
			((CassettePlayer)(object)target).EjectCassetteClientRpc();
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	protected internal override string __getTypeName()
	{
		return "CassettePlayer";
	}
}
internal class Assets
{
	internal static AssetBundle mainAssetBundle;

	private static string[] assetNames = new string[0];

	internal static void LoadAssetBundle(string assetBundlePath)
	{
		if ((Object)(object)mainAssetBundle == (Object)null)
		{
			mainAssetBundle = AssetBundle.LoadFromFile(assetBundlePath);
		}
		assetNames = mainAssetBundle.GetAllAssetNames();
	}

	internal static AssetBundle GetBundle()
	{
		return mainAssetBundle;
	}
}