using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MoreCompany.Cosmetics;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Rendering;
using _3rdPerson.Helper;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("3rdPerson")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("3rdPerson")]
[assembly: AssemblyTitle("3rdPerson")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace _3rdPerson
{
	[BepInPlugin("verity.3rdperson", "3rd Person", "1.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static readonly Harmony Harmony = new Harmony("verity.3rdperson");

		public static ManualLogSource LogSource = null;

		public static ConfigEntry<string> KeybindEntry = null;

		public static ConfigEntry<string> OrbitKeybindEntry = null;

		public static ConfigEntry<float> OrbitSpeedEntry = null;

		public static ConfigEntry<float> Distance = null;

		public static ConfigEntry<float> RightOffset = null;

		public static ConfigEntry<float> UpOffset = null;

		public static ConfigEntry<bool> MoreCompanyCosmetics = null;

		private void Awake()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			GameObject val = new GameObject("3rdPerson");
			val.AddComponent<PluginLoader>();
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)val);
			LogSource = ((BaseUnityPlugin)this).Logger;
			LogSource.LogInfo((object)"3rd Person Mod Loaded.");
			KeybindEntry = ((BaseUnityPlugin)this).Config.Bind<string>("Camera Settings", "Keybind", "c", "The keybind used to toggle third person.");
			Distance = ((BaseUnityPlugin)this).Config.Bind<float>("Camera Settings", "Distance", 2f, "Distance of the camera from the player.");
			RightOffset = ((BaseUnityPlugin)this).Config.Bind<float>("Camera Settings", "Right-Offset", 0.6f, "Offset of the camera to the right from the player.");
			UpOffset = ((BaseUnityPlugin)this).Config.Bind<float>("Camera Settings", "Up-Offset", 0.1f, "Offset of the camera upwards from the player.");
			OrbitKeybindEntry = ((BaseUnityPlugin)this).Config.Bind<string>("Orbit Settings", "Keybind", "<Mouse>/middleButton", "The keybind used to 'orbit' around the player.");
			OrbitSpeedEntry = ((BaseUnityPlugin)this).Config.Bind<float>("Orbit Settings", "Orbit-Speed", 75f, "The speed/sensitivity of the orbiting.");
			MoreCompanyCosmetics = ((BaseUnityPlugin)this).Config.Bind<bool>("Mod Support", "MoreCompany-Cosmetic-Support", false, "Displays MoreCompany Cosmetics in third person, this can mess with first person visibility if you have glasses on.");
		}
	}
	public class PluginLoader : MonoBehaviour
	{
		private void Start()
		{
			LocalPlayer localPlayer = ((Component)this).gameObject.AddComponent<LocalPlayer>();
			((Object)localPlayer).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)localPlayer);
			Keybinding keybinding = ((Component)this).gameObject.AddComponent<Keybinding>();
			((Object)keybinding).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)keybinding);
			ThirdPersonCamera thirdPersonCamera = ((Component)this).gameObject.AddComponent<ThirdPersonCamera>();
			((Object)thirdPersonCamera).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)thirdPersonCamera);
			Hooks.Init();
		}
	}
}
namespace _3rdPerson.Helper
{
	public static class Hooks
	{
		private class HarmonyHooks
		{
			private static bool _previousState;

			public static void MenuOpenedHook()
			{
				_previousState = ThirdPersonCamera.ViewState;
				if (LocalPlayer.IsActive() && ThirdPersonCamera.ViewState)
				{
					LocalPlayer.GetController().quickMenuManager.isMenuOpen = false;
					ThirdPersonCamera.Toggle();
				}
			}

			public static void MenuClosedHook()
			{
				if (LocalPlayer.IsActive() && _previousState)
				{
					LocalPlayer.GetController().inTerminalMenu = false;
					ThirdPersonCamera.Toggle();
				}
			}

			public static void MoreCompanyHook()
			{
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				CosmeticApplication val = Object.FindObjectOfType<CosmeticApplication>();
				if (CosmeticRegistry.locallySelectedCosmetics.Count <= 0 || val.spawnedCosmetics.Count > 0)
				{
					return;
				}
				foreach (string locallySelectedCosmetic in CosmeticRegistry.locallySelectedCosmetics)
				{
					val.ApplyCosmetic(locallySelectedCosmetic, true);
				}
				foreach (CosmeticInstance spawnedCosmetic in val.spawnedCosmetics)
				{
					Transform transform = ((Component)spawnedCosmetic).transform;
					transform.localScale *= 0.38f;
					SetAllChildrenLayer(((Component)spawnedCosmetic).transform, 29);
				}
			}

			private static void SetAllChildrenLayer(Transform transform, int layer)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Expected O, but got Unknown
				((Component)transform).gameObject.layer = layer;
				foreach (Transform item in transform)
				{
					SetAllChildrenLayer(item, layer);
				}
			}

			public static bool PlayerInputHook()
			{
				if (ThirdPersonCamera.ViewState)
				{
					return !Keybinding.orbitAction.IsPressed();
				}
				return true;
			}

			public static void KillPlayerHook()
			{
				if (ThirdPersonCamera.ViewState)
				{
					ThirdPersonCamera.Toggle();
				}
			}
		}

		public static void Init()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Expected O, but got Unknown
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Expected O, but got Unknown
			MethodInfo method = typeof(QuickMenuManager).GetMethod("OpenQuickMenu");
			MethodInfo method2 = typeof(HarmonyHooks).GetMethod("MenuOpenedHook");
			Plugin.Harmony.Patch((MethodBase)method, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.LogSource.LogInfo((object)"Open Menu Hooked.");
			MethodInfo method3 = typeof(QuickMenuManager).GetMethod("CloseQuickMenu");
			MethodInfo method4 = typeof(HarmonyHooks).GetMethod("MenuClosedHook");
			Plugin.Harmony.Patch((MethodBase)method3, new HarmonyMethod(method4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.LogSource.LogInfo((object)"Close Menu Hooked.");
			MethodInfo method5 = typeof(Terminal).GetMethod("BeginUsingTerminal");
			MethodInfo method6 = typeof(HarmonyHooks).GetMethod("MenuOpenedHook");
			Plugin.Harmony.Patch((MethodBase)method5, new HarmonyMethod(method6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.LogSource.LogInfo((object)"Open Terminal Hooked.");
			MethodInfo method7 = typeof(Terminal).GetMethod("QuitTerminal");
			MethodInfo method8 = typeof(HarmonyHooks).GetMethod("MenuClosedHook");
			Plugin.Harmony.Patch((MethodBase)method7, new HarmonyMethod(method8), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.LogSource.LogInfo((object)"Close Terminal Hooked.");
			MethodInfo method9 = typeof(PlayerControllerB).GetMethod("PlayerLookInput", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method10 = typeof(HarmonyHooks).GetMethod("PlayerInputHook");
			Plugin.Harmony.Patch((MethodBase)method9, new HarmonyMethod(method10), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.LogSource.LogInfo((object)"Player Look Input Hooked.");
			MethodInfo method11 = typeof(PlayerControllerB).GetMethod("KillPlayer");
			MethodInfo method12 = typeof(HarmonyHooks).GetMethod("KillPlayerHook");
			Plugin.Harmony.Patch((MethodBase)method11, new HarmonyMethod(method12), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.LogSource.LogInfo((object)"Player Killed Hooked.");
			if (Chainloader.PluginInfos.ContainsKey("me.swipez.melonloader.morecompany") && Plugin.MoreCompanyCosmetics.Value)
			{
				MethodInfo method13 = typeof(HUDManager).GetMethod("AddPlayerChatMessageClientRpc", BindingFlags.Instance | BindingFlags.NonPublic);
				MethodInfo method14 = typeof(HarmonyHooks).GetMethod("MoreCompanyHook");
				Plugin.Harmony.Patch((MethodBase)method13, (HarmonyMethod)null, new HarmonyMethod(method14), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Plugin.LogSource.LogInfo((object)"MoreCompany Cosmetics Added.");
			}
			Plugin.LogSource.LogInfo((object)"Hooks Initialized.");
		}
	}
	public class Keybinding : MonoBehaviour
	{
		public static InputAction orbitAction;

		private void Awake()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			InputAction val = new InputAction((string)null, (InputActionType)0, "<Keyboard>/" + Plugin.KeybindEntry.Value, (string)null, (string)null, (string)null);
			val.performed += KeyPressed;
			val.Enable();
			orbitAction = new InputAction("MouseLeftClick", (InputActionType)0, Plugin.OrbitKeybindEntry.Value ?? "", (string)null, (string)null, (string)null);
			orbitAction.Enable();
		}

		private void KeyPressed(CallbackContext obj)
		{
			ThirdPersonCamera.Toggle();
		}

		private void OnEnable()
		{
			Plugin.LogSource.LogInfo((object)("Keybinding Initialized, Current Keybind " + Plugin.KeybindEntry.Value + "."));
		}
	}
	public class LocalPlayer : MonoBehaviour
	{
		private static PlayerControllerB? _playerController;

		public void OnEnable()
		{
			Plugin.LogSource.LogInfo((object)"Local Player Caching Initialized.");
		}

		private void Update()
		{
			if (GameNetworkManager.Instance != null)
			{
				_playerController = GameNetworkManager.Instance.localPlayerController;
			}
		}

		public static bool IsActive()
		{
			if ((Object)(object)_playerController != (Object)null)
			{
				return !_playerController.isPlayerDead;
			}
			return false;
		}

		public static PlayerControllerB GetController()
		{
			return _playerController;
		}
	}
	public class ThirdPersonCamera : MonoBehaviour
	{
		private static Camera _camera;

		public static bool ViewState;

		public static Camera GetCamera => _camera;

		private void Awake()
		{
			_camera = ((Component)this).gameObject.AddComponent<Camera>();
			((Object)_camera).hideFlags = (HideFlags)61;
			_camera.fieldOfView = 66f;
			_camera.nearClipPlane = 0.1f;
			_camera.cullingMask = 557520895;
			if (Chainloader.PluginInfos.ContainsKey("quackandcheese.mirrordecor"))
			{
				_camera.cullingMask = 557520887;
			}
			((Behaviour)_camera).enabled = false;
			Object.DontDestroyOnLoad((Object)(object)_camera);
		}

		private void OnEnable()
		{
			Plugin.LogSource.LogInfo((object)"Third Person Camera Initialized.");
		}

		private void Update()
		{
			if (!LocalPlayer.IsActive() || LocalPlayer.GetController().quickMenuManager.isMenuOpen || LocalPlayer.GetController().inTerminalMenu || LocalPlayer.GetController().isPlayerDead)
			{
				return;
			}
			if (Object.FindObjectsOfType<CentipedeAI>().Any((CentipedeAI centipede) => (Object)(object)centipede.clingingToPlayer != (Object)null && centipede.clingingToPlayer.playerClientId == NetworkManager.Singleton.LocalClientId))
			{
				Plugin.LogSource.LogInfo((object)"Centipede On Player!");
				if (ViewState)
				{
					Toggle();
				}
			}
			else if (!Keybinding.orbitAction.IsPressed())
			{
				ThirdPersonUpdate();
			}
			else
			{
				ThirdPersonOrbitUpdate();
			}
		}

		private void ThirdPersonUpdate()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0040: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			Camera gameplayCamera = LocalPlayer.GetController().gameplayCamera;
			Vector3 val = ((Component)gameplayCamera).transform.forward * -1f;
			Vector3 val2 = ((Component)gameplayCamera).transform.TransformDirection(Vector3.right) * Plugin.RightOffset.Value;
			Vector3 val3 = Vector3.up * Plugin.UpOffset.Value;
			float value = Plugin.Distance.Value;
			((Component)_camera).transform.position = ((Component)gameplayCamera).transform.position + val * value + val2 + val3;
			((Component)_camera).transform.rotation = Quaternion.LookRotation(((Component)gameplayCamera).transform.forward);
		}

		private void ThirdPersonOrbitUpdate()
		{
			//IL_000a: 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)
			//IL_0017: 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)
			//IL_0037: 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)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			MovementActions movement = LocalPlayer.GetController().playerActions.Movement;
			Vector2 val = ((MovementActions)(ref movement)).Look.ReadValue<Vector2>() * (0.008f * (float)IngamePlayerSettings.Instance.settings.lookSensitivity);
			if (IngamePlayerSettings.Instance.settings.invertYAxis)
			{
				val.y *= -1f;
			}
			((Component)_camera).transform.Rotate(Vector3.right, val.y * Plugin.OrbitSpeedEntry.Value * Time.deltaTime);
			((Component)_camera).transform.RotateAround(((Component)LocalPlayer.GetController().gameplayCamera).transform.position, Vector3.up, val.x * Plugin.OrbitSpeedEntry.Value * Time.deltaTime);
			float value = Plugin.Distance.Value;
			((Component)_camera).transform.position = ((Component)LocalPlayer.GetController().gameplayCamera).transform.position - ((Component)_camera).transform.forward * value;
		}

		public static void Toggle()
		{
			if (!LocalPlayer.IsActive() || LocalPlayer.GetController().isTypingChat || LocalPlayer.GetController().quickMenuManager.isMenuOpen || LocalPlayer.GetController().inTerminalMenu || LocalPlayer.GetController().isPlayerDead)
			{
				return;
			}
			ViewState = !ViewState;
			GameObject val = GameObject.Find("Systems/UI/Canvas/Panel/");
			Canvas component = GameObject.Find("Systems/UI/Canvas/").GetComponent<Canvas>();
			if (ViewState)
			{
				if (!Chainloader.PluginInfos.ContainsKey("quackandcheese.mirrordecor"))
				{
					((Renderer)LocalPlayer.GetController().thisPlayerModel).shadowCastingMode = (ShadowCastingMode)1;
				}
				val.SetActive(false);
				component.worldCamera = _camera;
				component.renderMode = (RenderMode)0;
				GameObject.Find("Systems/Rendering/PlayerHUDHelmetModel/").SetActive(false);
				((Renderer)LocalPlayer.GetController().thisPlayerModelArms).enabled = false;
				((Behaviour)LocalPlayer.GetController().gameplayCamera).enabled = false;
				((Behaviour)_camera).enabled = true;
			}
			else
			{
				if (!Chainloader.PluginInfos.ContainsKey("quackandcheese.mirrordecor"))
				{
					((Renderer)LocalPlayer.GetController().thisPlayerModel).shadowCastingMode = (ShadowCastingMode)3;
				}
				val.SetActive(true);
				component.worldCamera = GameObject.Find("UICamera").GetComponent<Camera>();
				component.renderMode = (RenderMode)1;
				GameObject.Find("Systems/Rendering/PlayerHUDHelmetModel/").SetActive(true);
				((Renderer)LocalPlayer.GetController().thisPlayerModelArms).enabled = true;
				((Behaviour)LocalPlayer.GetController().gameplayCamera).enabled = true;
				((Behaviour)_camera).enabled = false;
			}
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("AEIOUCompany")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Jogn Maden")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AEIOUCompany")]
[assembly: AssemblyTitle("AEIOUCompany")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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;
		}
	}
}
public class Speak
{
	public string ChatMessage;

	public int PlayerId;

	public Speak(string chatMessage, int playerId)
	{
		ChatMessage = chatMessage;
		PlayerId = playerId;
	}
}
namespace AEIOU_Company
{
	[HarmonyPatch]
	public class Patches
	{
		private static int NEW_CHAT_SIZE = Plugin.ChatSize;

		private static TMP_InputField chatTextField = null;

		private static string lastChatMessage = "";

		private static readonly float[] emptySamples = new float[TTS.IN_BUFFER_SIZE];

		private static List<Speak> _speaks = new List<Speak>();

		private static bool _isProcessing = false;

		[HarmonyPatch(typeof(HUDManager), "AddPlayerChatMessageClientRpc")]
		[HarmonyPostfix]
		public static void AddPlayerChatMessageClientRpcPostfix(HUDManager __instance, string chatMessage, int playerId)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (lastChatMessage == chatMessage)
			{
				return;
			}
			lastChatMessage = chatMessage;
			if (playerId > HUDManager.Instance.playersManager.allPlayerScripts.Length)
			{
				return;
			}
			bool flag = GameNetworkManager.Instance.localPlayerController.holdingWalkieTalkie && StartOfRound.Instance.allPlayerScripts[playerId].holdingWalkieTalkie;
			float num = Vector3.Distance(((Component)GameNetworkManager.Instance.localPlayerController).transform.position, ((Component)HUDManager.Instance.playersManager.allPlayerScripts[playerId]).transform.position);
			if (num > 25f && !flag && GameNetworkManager.Instance.localPlayerController.isPlayerDead)
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(HUDManager), "AddChatMessage", (Type[])null, (Type[])null);
				methodInfo.Invoke(HUDManager.Instance, new object[2]
				{
					chatMessage,
					HUDManager.Instance.playersManager.allPlayerScripts[playerId].playerUsername
				});
			}
			Plugin.Log($"AddTextToChatOnServer: {chatMessage} {playerId}");
			QueueSpeak(__instance, chatMessage, playerId);
			if (_isProcessing)
			{
				return;
			}
			_isProcessing = true;
			Task.Run(delegate
			{
				while (_speaks.Count > 0)
				{
					try
					{
						Speak(__instance, _speaks[0].ChatMessage, _speaks[0].PlayerId);
						_speaks.RemoveAt(0);
					}
					catch (Exception data)
					{
						Plugin.Log(data);
						_speaks.Clear();
						_isProcessing = false;
						return;
					}
				}
				_isProcessing = false;
			});
		}

		public static void Speak(HUDManager __instance, string chatMessage, int playerId)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log("Speak");
			PlayerControllerB val = null;
			for (int i = 0; i < __instance.playersManager.allPlayerScripts.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)__instance.playersManager.allPlayerScripts[playerId]))
				{
					val = __instance.playersManager.allPlayerScripts[playerId];
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log("couldnt find player");
				return;
			}
			Plugin.Log("Found player");
			Transform obj = ((Component)val).gameObject.transform.Find("AEIOUSpeakObject");
			GameObject val2 = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = new GameObject("AEIOUSpeakObject");
				val2.transform.parent = ((Component)val).transform;
				val2.transform.localPosition = Vector3.zero;
				val2.AddComponent<AudioSource>();
				val2.AddComponent<AudioHighPassFilter>();
				val2.AddComponent<AudioLowPassFilter>();
			}
			Plugin.Log("Found AEIOUSpeakObject");
			AudioSource component = val2.GetComponent<AudioSource>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.LogError("Couldn't speak, AudioSource was null");
				return;
			}
			string message = chatMessage.Replace("\r", "").Replace("\n", "");
			float[] array = TTS.SpeakToMemory(message, 7.5f);
			if ((Object)(object)component.clip == (Object)null)
			{
				component.clip = AudioClip.Create("AEIOUCLIP", TTS.IN_BUFFER_SIZE, 1, 11025, false);
			}
			Plugin.Log("Setting up clip");
			component.clip.SetData(emptySamples, 0);
			component.clip.SetData(array, 0);
			component.outputAudioMixerGroup = SoundManager.Instance.playerVoiceMixers[val.playerClientId];
			component.rolloffMode = (AudioRolloffMode)2;
			component.minDistance = 1f;
			component.maxDistance = 40f;
			component.dopplerLevel = Plugin.TTSDopperLevel;
			component.pitch = 1f;
			component.spatialize = true;
			component.spatialBlend = (val.isPlayerDead ? 0f : 1f);
			bool flag = !val.isPlayerDead || StartOfRound.Instance.localPlayerController.isPlayerDead;
			component.volume = (flag ? Plugin.TTSVolume : 0f);
			AudioHighPassFilter component2 = val2.GetComponent<AudioHighPassFilter>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			AudioLowPassFilter component3 = val2.GetComponent<AudioLowPassFilter>();
			if ((Object)(object)component3 != (Object)null)
			{
				component3.lowpassResonanceQ = 1f;
				component3.cutoffFrequency = 5000f;
			}
			if (component.isPlaying)
			{
				component.Stop(true);
			}
			Plugin.Log("Playing audio: " + ((object)component).ToString() + component.volume);
			if (val.holdingWalkieTalkie)
			{
				GrabbableObject currentlyHeldObjectServer = val.currentlyHeldObjectServer;
				WalkieTalkie val3 = (WalkieTalkie)(object)((currentlyHeldObjectServer is WalkieTalkie) ? currentlyHeldObjectServer : null);
				if (val3 != null)
				{
					Plugin.Log("WalkieTalkie");
					bool flag2 = false;
					for (int j = 0; j < WalkieTalkie.allWalkieTalkies.Count; j++)
					{
						if ((Object)(object)((GrabbableObject)WalkieTalkie.allWalkieTalkies[j]).playerHeldBy == (Object)(object)StartOfRound.Instance.localPlayerController && ((GrabbableObject)WalkieTalkie.allWalkieTalkies[j]).isBeingUsed)
						{
							flag2 = true;
						}
					}
					if ((Object)(object)val3 != (Object)null && ((GrabbableObject)val3).isBeingUsed && flag2)
					{
						component.volume = Plugin.TTSVolume;
						if ((Object)(object)val == (Object)(object)StartOfRound.Instance.localPlayerController)
						{
							Plugin.Log("Pushing walkie button");
							val.playerBodyAnimator.SetBool("walkieTalkie", true);
							((MonoBehaviour)val3).StartCoroutine(WaitAndStopUsingWalkieTalkie(component.clip, val));
						}
						else
						{
							((Behaviour)component2).enabled = true;
							component3.lowpassResonanceQ = 3f;
							component3.cutoffFrequency = 4000f;
							component.spatialBlend = 0f;
						}
					}
				}
			}
			component.PlayOneShot(component.clip, 1f);
			RoundManager.Instance.PlayAudibleNoise(val2.transform.position, 25f, 0.7f, 0, false, 0);
		}

		public static void QueueSpeak(HUDManager __instance, string chatMessage, int playerId)
		{
			Plugin.Log("Queueing speak");
			_speaks.Add(new Speak(chatMessage, playerId));
		}

		public static IEnumerator WaitAndStopUsingWalkieTalkie(AudioClip clip, PlayerControllerB player)
		{
			Plugin.Log($"WalkieButton Length {TTS.CurrentAudioLengthInSeconds}");
			yield return (object)new WaitForSeconds(TTS.CurrentAudioLengthInSeconds);
			Plugin.Log("WalkieButton end");
			player.playerBodyAnimator.SetBool("walkieTalkie", false);
		}

		[HarmonyPatch(typeof(HUDManager), "EnableChat_performed")]
		[HarmonyPostfix]
		public static void EnableChat_performedPostfix(ref TMP_InputField ___chatTextField, HUDManager __instance)
		{
			___chatTextField.characterLimit = NEW_CHAT_SIZE;
			chatTextField = ___chatTextField;
			Plugin.Log("Enable Chat");
		}

		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
		[HarmonyPostfix]
		public static void KillPlayerPostfix(PlayerControllerB __instance)
		{
			HUDManager.Instance.HideHUD(false);
			HUDManager.Instance.UpdateHealthUI(100, false);
			Plugin.Log("Player died, re-enabling UI");
		}

		[HarmonyPatch(typeof(HUDManager), "EnableChat_performed")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> EnableChat_performedTranspiler(IEnumerable<CodeInstruction> oldInstructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(oldInstructions);
			for (int i = 0; i < list.Count - 3; i++)
			{
				if (list[i].opcode == OpCodes.Ldarg_0 && CodeInstructionExtensions.Is(list[i + 1], OpCodes.Ldfld, (MemberInfo)AccessTools.Field(typeof(HUDManager), "localPlayer")) && CodeInstructionExtensions.Is(list[i + 2], OpCodes.Ldfld, (MemberInfo)AccessTools.Field(typeof(PlayerControllerB), "isPlayerDead")) && list[i + 3].opcode == OpCodes.Brfalse)
				{
					Plugin.Log("Patching dead chat in EnableChat_performed");
					list[i].opcode = OpCodes.Br;
					list[i].operand = list[i + 3].operand;
					break;
				}
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(HUDManager), "SubmitChat_performed")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> SubmitChat_performedTranspiler(IEnumerable<CodeInstruction> oldInstructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(oldInstructions);
			patchMaxChatSize(list);
			patchDeadChat(list);
			return list.AsEnumerable();
			static void patchDeadChat(List<CodeInstruction> newInstructions)
			{
				for (int i = 0; i < newInstructions.Count - 3; i++)
				{
					if (newInstructions[i].opcode == OpCodes.Ldarg_0 && CodeInstructionExtensions.Is(newInstructions[i + 1], OpCodes.Ldfld, (MemberInfo)AccessTools.Field(typeof(HUDManager), "localPlayer")) && CodeInstructionExtensions.Is(newInstructions[i + 2], OpCodes.Ldfld, (MemberInfo)AccessTools.Field(typeof(PlayerControllerB), "isPlayerDead")) && newInstructions[i + 3].opcode == OpCodes.Brfalse)
					{
						Plugin.Log("Patching dead chat in SubmitChat_performed");
						newInstructions[i].opcode = OpCodes.Br;
						newInstructions[i].operand = newInstructions[i + 3].operand;
						break;
					}
				}
			}
			static void patchMaxChatSize(List<CodeInstruction> newInstructions)
			{
				CodeInstruction val = null;
				bool flag = false;
				foreach (CodeInstruction newInstruction in newInstructions)
				{
					if (CodeInstructionExtensions.Is(newInstruction, OpCodes.Ldc_I4_S, (object)50))
					{
						flag = true;
						val = newInstruction;
					}
					else
					{
						if (newInstruction.opcode == OpCodes.Bge && flag)
						{
							val.opcode = OpCodes.Ldc_I4;
							val.operand = NEW_CHAT_SIZE + 1;
							Plugin.Log("Patched max chat length");
							break;
						}
						if (flag)
						{
							flag = false;
							val = null;
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(HUDManager), "AddPlayerChatMessageServerRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> AddPlayerChatMessageServerRpcTranspiler(IEnumerable<CodeInstruction> oldInstructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(oldInstructions);
			foreach (CodeInstruction item in list)
			{
				if (CodeInstructionExtensions.Is(item, OpCodes.Ldc_I4_S, (object)50))
				{
					item.opcode = OpCodes.Ldc_I4;
					item.operand = NEW_CHAT_SIZE;
					Plugin.Log("Patched server max chat length");
					break;
				}
			}
			return list.AsEnumerable();
		}
	}
	public class LCModUtils
	{
		private static Harmony _harmony;

		private static bool _shouldHost;

		private static bool _shouldJoin;

		public LCModUtils(Harmony harmony)
		{
			_harmony = harmony;
		}

		public void DisableFullscreen()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(IngamePlayerSettings), "SetFullscreenMode", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.LogError("Couldn't find method SetFullscreenMode");
			}
			MethodInfo methodInfo2 = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => SetFullScreenModePrefix()));
			_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.Log("Disabled Fullscreen");
		}

		public void BootToLANMenu()
		{
			Plugin.Log("Attempting to load lan scene");
			SceneManager.sceneLoaded += OnSceneLoaded;
			SceneManager.LoadScene("InitSceneLANMode");
		}

		public void StartLANHost()
		{
			BootToLANMenu();
			_shouldHost = true;
		}

		public void StartLANClient()
		{
			BootToLANMenu();
			_shouldJoin = true;
		}

		private static bool SetFullScreenModePrefix()
		{
			return false;
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			MenuManager val = Object.FindObjectOfType<MenuManager>();
			if (!(((Scene)(ref scene)).name == "MainMenu"))
			{
				return;
			}
			Plugin.Log("MainMenuLoaded");
			GameObject lanWarningContainer = val.lanWarningContainer;
			if (Object.op_Implicit((Object)(object)lanWarningContainer))
			{
				Plugin.Log("Destroy LAN Warning");
				Object.Destroy((Object)(object)lanWarningContainer);
			}
			else
			{
				Plugin.Log("LANWarning Null");
			}
			if (_shouldHost || _shouldJoin)
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(MenuManager), "Start", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Plugin.LogError("Couldn't find method \"Start\" in MenuManager");
				}
				MethodInfo methodInfo2 = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => HostOrJoin()));
				_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		private static void HostOrJoin()
		{
			MenuManager val = Object.FindObjectOfType<MenuManager>();
			if (_shouldHost)
			{
				if (val != null)
				{
					val.ClickHostButton();
				}
				if (val != null)
				{
					val.ConfirmHostButton();
				}
			}
			else if (_shouldJoin)
			{
				AccessTools.Method(typeof(MenuManager), "ClickJoinButton", (Type[])null, (Type[])null)?.Invoke(val, null);
			}
		}
	}
	[BepInPlugin("AEIOUCompany", "AEIOUCompany", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static Harmony Harmony;

		protected static ManualLogSource Logger;

		public static bool PlayStartingUpMessage;

		public static float TTSVolume;

		public static float TTSDopperLevel;

		public static int ChatSize;

		public static void Log(object data)
		{
			ManualLogSource logger = Logger;
			if (logger != null)
			{
				logger.LogInfo(data);
			}
		}

		public static void LogError(object data)
		{
			ManualLogSource logger = Logger;
			if (logger != null)
			{
				logger.LogError(data);
			}
		}

		public void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			Harmony harmony = new Harmony("AEIOUCompany");
			Harmony = harmony;
			Logger = ((BaseUnityPlugin)this).Logger;
			PlayStartingUpMessage = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "StartingUpMessage", true, "Enables \"starting up\" sound effect.").Value;
			TTSVolume = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Volume", 1f, "Volume scale of text-to-speech-voice. Values range from 0 to 1").Value;
			TTSDopperLevel = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Doppler Effect Level", 1f, "Values range from 0 to 1").Value;
			ChatSize = ((BaseUnityPlugin)this).Config.Bind<int>("Advanced", "Chat Character Limit", 1024, "WARNING: Everybody must have the same value set for this!").Value;
			TTS.Init();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin AEIOUCompany is loaded!");
			Harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Plugin total patches appled: {Harmony.GetPatchedMethods().Count()}");
		}

		public void OnDestroy()
		{
			if (PlayStartingUpMessage)
			{
				TTS.Speak("Starting Up");
			}
		}

		private void EnableTestMode()
		{
			LCModUtils lCModUtils = new LCModUtils(Harmony);
			lCModUtils.DisableFullscreen();
			lCModUtils.BootToLANMenu();
		}
	}
	public static class TTS
	{
		private static readonly int OUT_BUFFER_SIZE = 8192;

		public static readonly int IN_BUFFER_SIZE = 8388608;

		public static float CurrentAudioLengthInSeconds = 0f;

		private static float[] floatBuffer = new float[IN_BUFFER_SIZE];

		private static NamedPipeClientStream _namedPipeClientStream;

		private static StreamWriter _streamWriter;

		private static BinaryWriter _binaryWriter;

		private static BinaryReader _binaryReader;

		private static bool _initialized = false;

		public static void Init()
		{
			StartSpeakServer();
			try
			{
				_namedPipeClientStream = new NamedPipeClientStream("AEIOUCOMPANYMOD");
				_streamWriter = new StreamWriter(_namedPipeClientStream, Encoding.UTF8, OUT_BUFFER_SIZE, leaveOpen: true);
				_binaryWriter = new BinaryWriter(_namedPipeClientStream, Encoding.UTF8, leaveOpen: true);
				_binaryReader = new BinaryReader(_namedPipeClientStream, Encoding.UTF8, leaveOpen: true);
			}
			catch (IOException data)
			{
				Plugin.LogError(data);
			}
			ConnectToSpeakServer();
			_initialized = true;
		}

		public static void Speak(string message)
		{
			if (!_initialized)
			{
				Plugin.LogError("Tried to speak before initializing TTS!");
				return;
			}
			try
			{
				SendMsg(message, "msgA");
			}
			catch (IOException ex)
			{
				Plugin.LogError("Speak" + ex);
			}
		}

		public static float[] SpeakToMemory(string message, float volumeScale = 1f)
		{
			if (!_initialized)
			{
				Plugin.LogError("Tried to speak before initializing TTS!");
				return null;
			}
			SendMsg(message, "msg");
			ClearSamplesBuffer();
			int num = _binaryReader.ReadInt32();
			byte[] value = _binaryReader.ReadBytes(num);
			for (int i = 0; i < num - 1; i += 2)
			{
				int num2 = i / 2;
				float num3 = volumeScale * ((float)BitConverter.ToInt16(value, i) / 32767f);
				if (i < floatBuffer.Length)
				{
					floatBuffer[num2] = num3;
				}
			}
			int num4 = 0;
			for (int num5 = floatBuffer.Length - 1; num5 > 0; num5--)
			{
				if ((double)floatBuffer[num5] != 0.0)
				{
					num4 = num5;
					break;
				}
			}
			CurrentAudioLengthInSeconds = (float)num4 / 11025f;
			Plugin.Log("END");
			return floatBuffer;
		}

		private static void SendMsg(string message, string prefix)
		{
			Plugin.Log("Sending: " + prefix + "=" + message + "]");
			try
			{
				_streamWriter.WriteLine();
				_streamWriter.Flush();
			}
			catch (IOException ex)
			{
				if (ex.Message.Contains("Pipe is broken"))
				{
					StartSpeakServer();
					ConnectToSpeakServer();
				}
				else
				{
					Plugin.LogError(ex);
				}
			}
			catch (Exception data)
			{
				Plugin.LogError(data);
			}
			_streamWriter.WriteLine(prefix + "=[:np]" + message + "]");
			_streamWriter.Flush();
		}

		private static void ConnectToSpeakServer()
		{
			Plugin.Log("ConnectingToPipe");
			try
			{
				_namedPipeClientStream.Connect(7500);
			}
			catch (TimeoutException)
			{
				Plugin.LogError("Unable to connect to SpeakServer after timeout");
			}
			catch (IOException)
			{
				Plugin.LogError("IOException while trying to ConnectToSpeakServer");
			}
		}

		private static void ClearSamplesBuffer()
		{
			for (int i = 0; i < floatBuffer.Length; i++)
			{
				floatBuffer[i] = 0f;
			}
		}

		private static void StartSpeakServer()
		{
			if (CheckForAEIOUSPEAKProcess())
			{
				Process[] processesByName = Process.GetProcessesByName("AEIOUSpeak");
				Process[] array = processesByName;
				foreach (Process process in array)
				{
					process.Close();
				}
			}
			string text = new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath.Replace("AEIOUCompany.dll", "");
			Plugin.Log(text + "AEIOUSpeak.exe");
			Process process2 = Process.Start(text + "AEIOUSpeak.exe");
			Plugin.Log("Started Speak Server");
			if (process2 == null)
			{
				Plugin.LogError("Failed to start Speak Server");
			}
		}

		private static bool CheckForAEIOUSPEAKProcess()
		{
			Process[] processesByName = Process.GetProcessesByName("AEIOUSpeak");
			if (processesByName.Length != 0)
			{
				return true;
			}
			return false;
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "AEIOUCompany";

		public const string PLUGIN_NAME = "AEIOUCompany";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}