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.Versioning;
using System.Security.Cryptography;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using PajamaManUnleashed.Coroutines;
using PajamaManUnleashed.Generators;
using PajamaManUnleashed.Managers;
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("PajamaManUnleashed")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PajamaManUnleashed")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fd96b2a5-f2fc-498a-8d46-3cb44762acb3")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PajamaManUnleashed
{
	[BepInPlugin("com.actus.lethalcompany.pajamamanunleashed", "Pajama Man Unleashed", "1.0.2")]
	public class PajamaManUnleashedBase : BaseUnityPlugin
	{
		private const string modGUID = "com.actus.lethalcompany.pajamamanunleashed";

		private const string modName = "Pajama Man Unleashed";

		private const string modVersion = "1.0.2";

		private readonly Harmony harmony = new Harmony("com.actus.lethalcompany.pajamamanunleashed");

		internal static ManualLogSource logger;

		internal static PajamaManUnleashedBase Instance;

		private static string baseFolderPath;

		internal AssetBundle networkAssets;

		internal static List<AudioClip> audioClips;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			logger = Logger.CreateLogSource("com.actus.lethalcompany.pajamamanunleashed");
			baseFolderPath = ((BaseUnityPlugin)Instance).Info.Location.TrimEnd("PajamaManUnleashed.dll".ToCharArray());
			networkAssets = AssetBundle.LoadFromFile(Path.Combine(baseFolderPath, "pajamamanasset"));
			audioClips = AssetBundle.LoadFromFile(Path.Combine(baseFolderPath, "pajamamansounds")).LoadAllAssets<AudioClip>().ToList();
			harmony.PatchAll();
			NetcodePatcher();
		}

		private static void NetcodePatcher()
		{
			logger.LogInfo((object)"NetcodePatcher is running!");
			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);
					}
				}
			}
		}
	}
}
namespace PajamaManUnleashed.Patches
{
	[HarmonyPatch(typeof(InteractTrigger), "Interact")]
	internal class InteractPatch
	{
		[HarmonyPrefix]
		public static void Interact(ref InteractTrigger __instance)
		{
			if (__instance.hoverTip.Contains("Squeeze") && SecureRandomNumberGenerator.GetRandomNumber(1, 100) <= 5)
			{
				PajamaManUnleashedBase.logger.LogInfo((object)"Trigger pajama man explosion!");
				NetworkHandler.Instance.TriggerPajamaManExplosion();
			}
		}
	}
	[HarmonyPatch]
	internal class NetworkObjectPatch
	{
		private static GameObject networkPrefab;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		public static void Init()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (!((Object)(object)networkPrefab != (Object)null))
			{
				networkPrefab = (GameObject)PajamaManUnleashedBase.Instance.networkAssets.LoadAsset("PajamaManNetworkManager.prefab");
				PajamaManUnleashedBase.logger.LogInfo((object)("Loaded PajamaManNetworkManager: " + (object)networkPrefab));
				networkPrefab.AddComponent<NetworkHandler>();
				NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
				PajamaManUnleashedBase.logger.LogInfo((object)"PajamaManNetworkManager added!");
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		private static void SpawnNetworkObject()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
				val.GetComponent<NetworkObject>().Spawn(false);
				PajamaManUnleashedBase.logger.LogInfo((object)"PajamaManNetworkManager spawned!");
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Update")]
	internal class UpdatePatch
	{
		private static float maxAnger = 50f;

		private static float angerIncreaseRate = 5f;

		private static float angerDecreaseRate = 0.1f;

		private static float angerDecreaseTimeOut = 2f;

		private static float scarePlayerTimeOut = 1f;

		private static float currentAnger = 0f;

		[HarmonyPostfix]
		public static void Update(ref PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && PajamaManHandler.IsPajamaManInUse())
			{
				if (PajamaManHandler.IsPlayerCurrentlyLookingAtPajamaMan(__instance.gameplayCamera))
				{
					IncreaseAnger(__instance);
				}
				else
				{
					DecreaseAnger();
				}
			}
		}

		private static void IncreaseAnger(PlayerControllerB __instance)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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)
			currentAnger = Mathf.Max(0f, currentAnger + angerIncreaseRate * Time.deltaTime);
			scarePlayerTimeOut = Mathf.Max(0f, scarePlayerTimeOut - Time.deltaTime);
			if (currentAnger > maxAnger)
			{
				PajamaManUnleashedBase.logger.LogInfo((object)"Killing player!");
				__instance.KillPlayer(Vector3.zero, true, (CauseOfDeath)0, 0, default(Vector3));
				currentAnger = 0f;
			}
			if (scarePlayerTimeOut <= 0f)
			{
				ScarePlayerHandler.ScarePlayer();
				scarePlayerTimeOut = 1f;
			}
			angerDecreaseTimeOut = 2f;
		}

		private static void DecreaseAnger()
		{
			if (currentAnger > 0f)
			{
				angerDecreaseTimeOut = Mathf.Max(0f, angerDecreaseTimeOut - Time.deltaTime);
				if (angerDecreaseTimeOut <= 0f)
				{
					currentAnger = Mathf.Max(0f, currentAnger - angerDecreaseRate * Time.deltaTime);
				}
			}
		}
	}
}
namespace PajamaManUnleashed.Managers
{
	internal class NetworkHandler : NetworkBehaviour
	{
		public static NetworkHandler Instance { get; private set; }

		[RuntimeInitializeOnLoadMethod]
		internal static void ConfigureRpcHandler()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			PajamaManUnleashedBase.logger.LogInfo((object)"[ConfigureRpcHandler] Starting RPC initialization process to ensure proper network communication.");
			NetworkManager.__rpc_func_table.Add(549048056u, new RpcReceiveHandler(__rpc_handler_549048056));
			NetworkManager.__rpc_func_table.Add(732399361u, new RpcReceiveHandler(__rpc_handler_732399361));
			PajamaManUnleashedBase.logger.LogInfo((object)"[ConfigureRpcHandler] RPC initialization completed successfully. Network communication is now set up.");
		}

		public override void OnNetworkSpawn()
		{
			PajamaManUnleashedBase.logger.LogInfo((object)"[OnNetworkSpawn] Initializing NetworkHandler instance. Preparing to set up network behavior and spawn logic.");
			if ((Object)(object)Instance != (Object)null && (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer))
			{
				((Component)Instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
			}
			Instance = this;
			((NetworkBehaviour)this).OnNetworkSpawn();
			PajamaManUnleashedBase.logger.LogInfo((object)"[OnNetworkSpawn] NetworkHandler instance successfully initialized and ready. Network behavior and spawn logic are now active.");
		}

		[ServerRpc(RequireOwnership = false)]
		public void TriggerPajamaManExplosion()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if ((Object)(object)networkManager != (Object)null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(549048056u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 549048056u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					PajamaManHandler.MarkPajamaManAsBuyableAgain();
					SyncExplosionToAllClients();
					((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(DelayedDestruction());
				}
			}
		}

		[ClientRpc]
		public void SyncExplosionToAllClients()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (!((Object)(object)networkManager == (Object)null) && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(732399361u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 732399361u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					PajamaManHandler.MarkPajamaManAsBuyableAgain();
					((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(DelayedExplosion());
				}
			}
		}

		private static void __rpc_handler_549048056(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if ((Object)(object)networkManager != (Object)null && networkManager.IsListening)
			{
				((NetworkBehaviour)(target as NetworkHandler)).__rpc_exec_stage = (__RpcExecStage)1;
				((NetworkHandler)(object)target).TriggerPajamaManExplosion();
				((NetworkBehaviour)(target as NetworkHandler)).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_732399361(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if ((Object)(object)networkManager != (Object)null && networkManager.IsListening)
			{
				((NetworkBehaviour)(target as NetworkHandler)).__rpc_exec_stage = (__RpcExecStage)2;
				((NetworkHandler)(object)target).SyncExplosionToAllClients();
				((NetworkBehaviour)(target as NetworkHandler)).__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static IEnumerator DelayedExplosion()
		{
			yield return (object)new WaitForSeconds(0.1f);
			Landmine.SpawnExplosion(PajamaManHandler.GetPajamaManPosition(), true, 5f, 15f, 50, 5f, (GameObject)null, false);
		}

		private static IEnumerator DelayedDestruction()
		{
			yield return (object)new WaitForSeconds(1f);
			PajamaManHandler.DespawnPajamaMan();
		}
	}
	public static class PajamaManHandler
	{
		private static string pajamaMan = "Plushie pajama man";

		private static float lookDistance = 10f;

		public static Vector3 GetPajamaManPosition()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)ProvidePajamaManAsPlacableShipItem()).transform.position;
		}

		public static bool IsPlayerCurrentlyLookingAtPajamaMan(Camera playerCamera)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)playerCamera).transform.position, ((Component)playerCamera).transform.forward);
			PlaceableShipObject val2 = ProvidePajamaManAsPlacableShipItem();
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			RaycastHit val3 = default(RaycastHit);
			return val2.placeObjectCollider.Raycast(val, ref val3, lookDistance);
		}

		public static bool IsPajamaManInUse()
		{
			UnlockableItem val = ProvidePajamaManAsUnlockableItem();
			if (val == null)
			{
				return false;
			}
			return (val.alreadyUnlocked || val.hasBeenUnlockedByPlayer) && !val.inStorage;
		}

		public static void MarkPajamaManAsBuyableAgain()
		{
			UnlockableItem val = ProvidePajamaManAsUnlockableItem();
			val.alreadyUnlocked = false;
			val.hasBeenUnlockedByPlayer = false;
			PlaceableShipObject val2 = ProvidePajamaManAsPlacableShipItem();
			StartOfRound.Instance.SpawnedShipUnlockables.Remove(val2.unlockableID);
		}

		public static void DespawnPajamaMan()
		{
			PlaceableShipObject val = ProvidePajamaManAsPlacableShipItem();
			NetworkObject val2 = default(NetworkObject);
			((Component)val.parentObject).TryGetComponent<NetworkObject>(ref val2);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.Despawn(true);
				PajamaManUnleashedBase.logger.LogInfo((object)"Despawned pajama man!");
			}
		}

		public static PlaceableShipObject ProvidePajamaManAsPlacableShipItem()
		{
			return ((IEnumerable<PlaceableShipObject>)Object.FindObjectsOfType<PlaceableShipObject>()).FirstOrDefault((Func<PlaceableShipObject, bool>)((PlaceableShipObject shipObject) => StartOfRound.Instance.unlockablesList.unlockables[shipObject.unlockableID].unlockableName == pajamaMan));
		}

		private static UnlockableItem ProvidePajamaManAsUnlockableItem()
		{
			return ((IEnumerable<UnlockableItem>)StartOfRound.Instance.unlockablesList.unlockables).FirstOrDefault((Func<UnlockableItem, bool>)((UnlockableItem i) => i.unlockableName == pajamaMan));
		}
	}
	public static class ScarePlayerHandler
	{
		public static void ScarePlayer()
		{
			int randomNumber = SecureRandomNumberGenerator.GetRandomNumber(1, 100);
			if (randomNumber <= 10)
			{
				PlayScarySound(randomNumber);
			}
			else if (randomNumber <= 40)
			{
				((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine((randomNumber <= 35) ? PlayWithLights() : PlayWithDoors());
			}
			RoundManager.Instance.FlickerLights(true, false);
		}

		private static void PlayScarySound(int randomValue)
		{
			string soundName = ((randomValue <= 5) ? "look_at_me" : "evil_laugh");
			AudioClip val = ((IEnumerable<AudioClip>)PajamaManUnleashedBase.audioClips).FirstOrDefault((Func<AudioClip, bool>)((AudioClip clip) => ((Object)clip).name == soundName));
			if ((Object)(object)val != (Object)null)
			{
				((Component)PajamaManHandler.ProvidePajamaManAsPlacableShipItem()).GetComponent<AudioSource>().PlayOneShot(val);
			}
		}

		private static IEnumerator PlayWithDoors()
		{
			HangarShipDoor hangarShipDoor = Object.FindObjectOfType<HangarShipDoor>();
			if (StartOfRound.Instance.shipDoorsEnabled)
			{
				bool state = StartOfRound.Instance.hangarDoorsClosed;
				for (int i = 0; i < 2; i++)
				{
					hangarShipDoor.PlayDoorAnimation(!state);
					yield return (object)new WaitForSeconds(1f);
					hangarShipDoor.PlayDoorAnimation(state);
					yield return (object)new WaitForSeconds(1f);
				}
			}
		}

		private static IEnumerator PlayWithLights()
		{
			ShipLights shipLights = Object.FindObjectOfType<ShipLights>();
			bool state = shipLights.areLightsOn;
			for (int i = 0; i < 2; i++)
			{
				shipLights.shipLightsAnimator.SetBool("lightsOn", !state);
				yield return (object)new WaitForSeconds(0.2f);
				shipLights.shipLightsAnimator.SetBool("lightsOn", state);
				yield return (object)new WaitForSeconds(0.2f);
			}
		}
	}
}
namespace PajamaManUnleashed.Generators
{
	internal class SecureRandomNumberGenerator
	{
		public static int GetRandomNumber(int minInclusive, int maxInclusive)
		{
			using RNGCryptoServiceProvider rNGCryptoServiceProvider = new RNGCryptoServiceProvider();
			byte[] array = new byte[4];
			rNGCryptoServiceProvider.GetBytes(array);
			int num = BitConverter.ToInt32(array, 0) & 0x7FFFFFFF;
			return minInclusive + num % (maxInclusive - minInclusive + 1);
		}
	}
}
namespace PajamaManUnleashed.Coroutines
{
	public class CoroutineRunner : MonoBehaviour
	{
		private static CoroutineRunner _instance;

		public static CoroutineRunner 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("CoroutineRunner");
					_instance = val.AddComponent<CoroutineRunner>();
					Object.DontDestroyOnLoad((Object)(object)val);
				}
				return _instance;
			}
		}
	}
}