using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ControlCompany.Core;
using ControlCompany.Core.Config;
using ControlCompany.Core.Enemy;
using ControlCompany.Core.Extentions;
using ControlCompany.Core.Input;
using ControlCompany.Core.UI;
using ControlCompany.Patches;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ControlCompany")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ControlCompany")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("dfed064e-ab44-4aa7-b361-7a59370d39a8")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ControlCompany
{
	[BepInPlugin("ControlCompany.ControlCompany", "ControlCompany", "1.0.6")]
	public class ControlCompanyPlugin : BaseUnityPlugin
	{
		private const string modGUID = "ControlCompany.ControlCompany";

		private const string modName = "ControlCompany";

		private const string modVersion = "1.0.6";

		private readonly Harmony harmony = new Harmony("ControlCompany.ControlCompany");

		public static ControlCompanyPlugin Instance;

		internal ManualLogSource logger;

		private bool isInitialized;

		private bool ranInitializationScripts;

		private void Awake()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			logger = Logger.CreateLogSource("ControlCompany.ControlCompany");
			logger.LogInfo((object)"Loaded ControlCompany. Patching.");
			ApplyPatches();
			logger.LogInfo((object)"Completed patching. Initializing control center.");
			GameObject val = new GameObject("control_company_control_center");
			val.AddComponent<ControlCenter>();
			((Object)val).hideFlags = (HideFlags)61;
			val.AddComponent<UIManager>();
			val.AddComponent<ConfigManager>().Initialize(((BaseUnityPlugin)this).Config);
			Object.DontDestroyOnLoad((Object)val);
			logger.LogInfo((object)"Completed initialization.");
			isInitialized = true;
		}

		private void ApplyPatches()
		{
			harmony.PatchAll(typeof(ControlCompanyPlugin));
			harmony.PatchAll(typeof(HUDManagerPatch));
			harmony.PatchAll(typeof(StartOfRoundPatch));
			harmony.PatchAll(typeof(PlayerControllerBPatch));
			harmony.PatchAll(typeof(EnemyAIPatch));
			harmony.PatchAll(typeof(TimeOfDayPatch));
		}
	}
}
namespace ControlCompany.Patches
{
	[HarmonyPatch(typeof(EnemyAI))]
	internal class EnemyAIPatch
	{
		[HarmonyPatch("ChangeOwnershipOfEnemy")]
		[HarmonyPrefix]
		private static bool ChangeOwnershipOfEnemyPrefix(EnemyAI __instance, ref ulong newOwnerClientId)
		{
			if ((Object)(object)ControlCenter.Instance != (Object)null)
			{
				if (ControlCenter.Instance.CurrentMode == ControlCenter.Mode.ENEMY)
				{
					if (ControlCenter.Instance.GetHostPlayer().actualClientId != newOwnerClientId && !ControlCenter.Instance.CurrentControlledEnemy.IsAIControlled)
					{
						return (Object)(object)ControlCenter.Instance.CurrentControlledEnemy.EnemyAI != (Object)(object)__instance;
					}
					return true;
				}
				return true;
			}
			return true;
		}

		[HarmonyPatch("ChangeEnemyOwnerServerRpc")]
		[HarmonyPrefix]
		private static bool ChangeEnemyOwnerServerRpcPrefix(EnemyAI __instance, ref ulong clientId)
		{
			if ((Object)(object)ControlCenter.Instance != (Object)null)
			{
				if (ControlCenter.Instance.CurrentMode == ControlCenter.Mode.ENEMY)
				{
					if (ControlCenter.Instance.GetHostPlayer().actualClientId != clientId && !ControlCenter.Instance.CurrentControlledEnemy.IsAIControlled)
					{
						return (Object)(object)ControlCenter.Instance.CurrentControlledEnemy.EnemyAI != (Object)(object)__instance;
					}
					return true;
				}
				return true;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal class HUDManagerPatch
	{
		[HarmonyPatch("CanPlayerScan")]
		[HarmonyPostfix]
		private static void CanPlayerScanPostfix(ref bool __result)
		{
			if (__result && (Object)(object)ControlCenter.Instance != (Object)null)
			{
				__result = ControlCenter.Instance.CurrentMode == ControlCenter.Mode.HOST;
			}
		}

		[HarmonyPatch("UpdateHealthUI")]
		[HarmonyPrefix]
		private static bool UpdateHealthUIPrefix()
		{
			if ((Object)(object)ControlCenter.Instance != (Object)null)
			{
				return ControlCenter.Instance.CurrentMode == ControlCenter.Mode.HOST;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerBPatch
	{
		[HarmonyPatch("PlayerLookInput")]
		[HarmonyPrefix]
		private static bool PlayerLookInputPrefix()
		{
			if ((Object)(object)ControlCenter.Instance != (Object)null)
			{
				return ControlCenter.Instance.CurrentMode == ControlCenter.Mode.HOST;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("ShipHasLeft")]
		[HarmonyPrefix]
		private static void ShipHasLeftPrefix()
		{
			if ((Object)(object)ControlCenter.Instance != (Object)null)
			{
				ControlCenter.Instance.EndOfRoundCleanUp();
			}
		}

		[HarmonyPatch("StartGame")]
		[HarmonyPostfix]
		private static void StartGamePostfix()
		{
			if ((Object)(object)ControlCenter.Instance != (Object)null)
			{
				ControlCenter.Instance.StartOfRoundInitialization();
			}
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal class TimeOfDayPatch
	{
		[HarmonyPatch("VoteShipToLeaveEarly")]
		[HarmonyPrefix]
		private static bool VoteToLeaveEarly()
		{
			if ((Object)(object)ControlCenter.Instance != (Object)null)
			{
				return ControlCenter.Instance.CurrentMode == ControlCenter.Mode.HOST;
			}
			return true;
		}
	}
}
namespace ControlCompany.Core
{
	internal static class Constants
	{
		public static Dictionary<int, string> ALL_LAYERS_DICT = (from index in Enumerable.Range(0, 32)
			where !string.IsNullOrEmpty(LayerMask.LayerToName(index))
			select index).ToDictionary((int index) => index, (int index) => LayerMask.LayerToName(index));

		public static LayerMask PLAYER_LOS_LAYER = LayerMask.op_Implicit(262144);

		public static LayerMask PLAYER_LAYER = LayerMask.op_Implicit(8);

		public static LayerMask ITERACTABLE_OBJ_LAYER = LayerMask.op_Implicit(512);

		public static LayerMask PROPS_LAYER = LayerMask.op_Implicit(64);

		public static LayerMask ENEMIES_LAYER = LayerMask.op_Implicit(524288);

		public static LayerMask PLAYER_RAGDOLL_LAYER = LayerMask.op_Implicit(1048576);
	}
	internal class ControlCenter : MonoBehaviour
	{
		public enum Mode
		{
			HOST,
			GHOST,
			ENEMY
		}

		public static ControlCenter Instance;

		private GameObject ghost;

		private EnemyController currentControlledEnemy;

		private int currentTargetIndex;

		private PlayerControllerB currentTarget;

		private Mode currentMode;

		private bool allowAllEnemies;

		private bool initialMicPushToTalkSetting;

		private bool hostDeadOnThisFrame;

		private bool isExtendedModeEnabled;

		private bool scrapSpawnMode;

		private int scrapSpawnPage;

		private int scrapSpawnPageSize = 10;

		private bool loadedConfig;

		private bool showUI = true;

		private float gameStartedTime;

		public Mode CurrentMode => currentMode;

		public EnemyController CurrentControlledEnemy => currentControlledEnemy;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		private void Update()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			if (!IsGameStarted())
			{
				return;
			}
			if (!loadedConfig)
			{
				loadedConfig = true;
				ConfigManager.Instance.LoadPlayerKeybinds();
			}
			if (((ButtonControl)InputKeys.TOGGLE_UI_KEY).wasPressedThisFrame)
			{
				showUI = !showUI;
			}
			gameStartedTime += Time.deltaTime;
			if (IsHost())
			{
				if (((Object)(object)currentTarget == (Object)null || !currentTarget.isPlayerControlled || currentTarget.isPlayerDead) && GetAlivePlayers().Count > 0)
				{
					SetNextTargetPlayer(1);
				}
				if ((Object)(object)ghost == (Object)null)
				{
					GameObject val = new GameObject("ghost");
					val.AddComponent<CustomPlayerController>().Initialize(GetHostPlayer().playerActions, CustomPlayerController.CameraMode.FIRST_PERSON);
					ghost = val;
					ghost.SetActive(false);
				}
				if (!hostDeadOnThisFrame && IsHostDead())
				{
					hostDeadOnThisFrame = true;
				}
				if (currentMode != 0)
				{
					GetHostPlayer().isTypingChat = true;
				}
				InputUpdate();
			}
		}

		private void InputUpdate()
		{
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			if (!IsGameStarted() || !IsHost())
			{
				return;
			}
			if (((ButtonControl)InputKeys.EXTENDED_MODE_KEY).wasPressedThisFrame)
			{
				isExtendedModeEnabled = !isExtendedModeEnabled;
				allowAllEnemies = isExtendedModeEnabled;
			}
			switch (currentMode)
			{
			case Mode.ENEMY:
				if (!currentControlledEnemy.IsAIControlled && !currentControlledEnemy.EnemyAI.isEnemyDead)
				{
					if (InputKeys.ENEMY_PRIMARY_SKILL_BUTTON.wasPressedThisFrame)
					{
						currentControlledEnemy.UsePrimarySkill();
					}
					else if (InputKeys.ENEMY_PRIMARY_SKILL_BUTTON.wasReleasedThisFrame)
					{
						currentControlledEnemy.ReleasePrimarySkill();
					}
					else if (InputKeys.ENEMY_SECONDARY_SKILL_BUTTON.wasPressedThisFrame)
					{
						currentControlledEnemy.UseSecondarySkill();
					}
					else if (InputKeys.ENEMY_SECONDARY_SKILL_BUTTON.wasReleasedThisFrame)
					{
						currentControlledEnemy.ReleaseSecondarySkill();
					}
					currentControlledEnemy.SetLockEnemyRotation(((ButtonControl)InputKeys.LOCK_ENEMY_ROTATION_KEY).isPressed);
				}
				if (((ButtonControl)InputKeys.EXIT_KEY).wasPressedThisFrame)
				{
					EnableGhost(enable: true, ((Component)currentControlledEnemy).transform.position);
					bool enable = IsTargetInside();
					ghost.GetComponentInChildren<CustomPlayerController>().EnableLight(enable);
					currentControlledEnemy.DestroyAndCleanUp();
					currentMode = Mode.GHOST;
				}
				else if (((ButtonControl)InputKeys.ENEMY_TOGGLE_AI_KEY).wasPressedThisFrame)
				{
					currentControlledEnemy.ToggleAIControl();
				}
				break;
			case Mode.HOST:
				if (((ButtonControl)InputKeys.HOST_GHOST_MODE_KEY).wasPressedThisFrame)
				{
					EnableGhost(enable: true, ((Component)currentTarget).gameObject.transform.position);
					bool enable2 = IsTargetInside();
					ghost.GetComponentInChildren<CustomPlayerController>().EnableLight(enable2);
					EnableHostPlayer(enable: false);
					currentMode = Mode.GHOST;
				}
				else if (((ButtonControl)InputKeys.HOST_CYCLE_PLAYER_TARGET_LIST_KEY_LEFT).wasPressedThisFrame)
				{
					SetNextTargetPlayer(-1);
				}
				else if (((ButtonControl)InputKeys.HOST_CYCLE_PLAYER_TARGET_LIST_KEY_RIGHT).wasPressedThisFrame)
				{
					SetNextTargetPlayer(1);
				}
				if (isExtendedModeEnabled)
				{
					if (((ButtonControl)InputKeys.HOST_TELEPORT_TO_ENTRANCE_KEY).wasPressedThisFrame)
					{
						((Component)GetHostPlayer()).gameObject.transform.position = RoundManager.FindMainEntrancePosition(true, false);
						GetHostPlayer().isInsideFactory = true;
					}
					else if (((ButtonControl)InputKeys.HOST_GIVE_CREDITS_KEY).wasPressedThisFrame)
					{
						Object.FindObjectOfType<Terminal>().groupCredits = 5000;
					}
				}
				break;
			case Mode.GHOST:
				if (!scrapSpawnMode)
				{
					bool isIndoor = IsTargetInside();
					List<SpawnableEnemyWithRarity> spawnableEnemies = GetSpawnableEnemies(isIndoor);
					for (int i = 0; i < InputKeys.GHOST_SPAWN_ENEMY_KEYS.Count && i < spawnableEnemies.Count; i++)
					{
						if (((ButtonControl)InputKeys.GHOST_SPAWN_ENEMY_KEYS[i]).wasPressedThisFrame)
						{
							currentControlledEnemy = SpawnControllableEnemy(spawnableEnemies[i], ghost.transform.position, ghost.transform.rotation);
							EnableGhost(enable: false);
							currentMode = Mode.ENEMY;
							break;
						}
					}
				}
				else
				{
					List<SpawnableItemWithRarity> list = ExtensionMethods.Chunk(GetSpawnableScraps(), scrapSpawnPageSize).ToList()[scrapSpawnPage].ToList();
					for (int j = 0; j < InputKeys.GHOST_SPAWN_ENEMY_KEYS.Count && j < list.Count; j++)
					{
						if (((ButtonControl)InputKeys.GHOST_SPAWN_ENEMY_KEYS[j]).wasPressedThisFrame)
						{
							SpawnScrap(list[j], ghost.transform.position);
							break;
						}
					}
				}
				if (((ButtonControl)InputKeys.EXIT_KEY).wasPressedThisFrame)
				{
					EnableGhost(enable: false);
					EnableHostPlayer(enable: true);
					currentMode = Mode.HOST;
					GetHostPlayer().isTypingChat = false;
				}
				_ = ((ButtonControl)Keyboard.current.upArrowKey).wasPressedThisFrame;
				if (scrapSpawnMode && ((ButtonControl)Keyboard.current.downArrowKey).wasPressedThisFrame)
				{
					int num = GetSpawnableScraps().Count / scrapSpawnPageSize;
					ControlCompanyPlugin.Instance.logger.LogMessage((object)$"Total scraps: {GetSpawnableScraps().Count()}, final page of scrap: {num}");
					scrapSpawnPage++;
					if (scrapSpawnPage > num)
					{
						scrapSpawnPage = 0;
					}
				}
				break;
			}
		}

		private bool IsTargetInside()
		{
			if ((Object)(object)currentTarget != (Object)null)
			{
				return currentTarget.isInsideFactory;
			}
			return false;
		}

		private void OnGUI()
		{
			if (!IsGameStarted() || !showUI)
			{
				return;
			}
			if (!IsHost())
			{
				if (gameStartedTime < 30f)
				{
					UIManager.Instance.RenderNotHostLabel(((InputControl)InputKeys.TOGGLE_UI_KEY).displayName);
				}
				return;
			}
			switch (currentMode)
			{
			case Mode.ENEMY:
				UIManager.Instance.RenderEnemyControls(((InputControl)InputKeys.ENEMY_PRIMARY_SKILL_BUTTON).shortDisplayName, ((InputControl)InputKeys.ENEMY_SECONDARY_SKILL_BUTTON).shortDisplayName, ((InputControl)InputKeys.ENEMY_TOGGLE_AI_KEY).displayName, ((InputControl)InputKeys.EXIT_KEY).displayName, currentControlledEnemy, GetHostPlayer());
				break;
			case Mode.HOST:
				UIManager.Instance.RenderHostControls(((InputControl)InputKeys.HOST_GHOST_MODE_KEY).displayName, ((InputControl)InputKeys.HOST_CYCLE_PLAYER_TARGET_LIST_KEY_LEFT).displayName, ((InputControl)InputKeys.HOST_CYCLE_PLAYER_TARGET_LIST_KEY_RIGHT).displayName, currentTarget, isExtendedModeEnabled, ((InputControl)InputKeys.HOST_GIVE_CREDITS_KEY).displayName, ((InputControl)InputKeys.HOST_TELEPORT_TO_ENTRANCE_KEY).displayName, ((InputControl)InputKeys.TOGGLE_UI_KEY).displayName);
				break;
			case Mode.GHOST:
			{
				bool isIndoor = IsTargetInside();
				UIManager.Instance.RenderGhostControls(InputKeys.GHOST_SPAWN_ENEMY_KEYS.Select((KeyControl key) => ((InputControl)key).displayName).ToList(), ((InputControl)InputKeys.EXIT_KEY).displayName, GetSpawnableEnemies(isIndoor), ExtensionMethods.Chunk(GetSpawnableScraps(), scrapSpawnPageSize).ToList()[scrapSpawnPage].ToList(), GetHostPlayer(), scrapSpawnMode);
				break;
			}
			}
		}

		private bool IsHostDead()
		{
			return GetHostPlayer().isPlayerDead;
		}

		private void EnableGhost(bool enable)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			EnableGhost(enable, Vector3.zero);
		}

		private void EnableGhost(bool enable, Vector3 position)
		{
			//IL_000e: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (enable)
			{
				ghost.transform.position = position + new Vector3(0f, 0.5f, 0f);
				ghost.transform.rotation = Quaternion.identity;
				ghost.SetActive(true);
			}
			else
			{
				ghost.SetActive(false);
			}
		}

		private void EnableHostPlayer(bool enable)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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)
			PlayerControllerB hostPlayer = GetHostPlayer();
			MovementActions movement;
			if (!enable)
			{
				ResetMicPushToTalk();
				HUDManager.Instance.HideHUD(false);
				((Behaviour)StartOfRound.Instance.audioListener).enabled = true;
				movement = hostPlayer.playerActions.Movement;
				((MovementActions)(ref movement)).PingScan.Disable();
			}
			else
			{
				initialMicPushToTalkSetting = IngamePlayerSettings.Instance.settings.pushToTalk;
				ForceMicPushToTalk();
				HUDManager.Instance.HideHUD(true);
				((Behaviour)StartOfRound.Instance.audioListener).enabled = false;
				movement = hostPlayer.playerActions.Movement;
				((MovementActions)(ref movement)).PingScan.Enable();
			}
		}

		private void EnablePlayer2DMics(bool enable, List<PlayerControllerB> players)
		{
			foreach (PlayerControllerB player in players)
			{
				if (player.isHostPlayerObject)
				{
					continue;
				}
				AudioSource currentVoiceChatAudioSource = player.currentVoiceChatAudioSource;
				if (enable)
				{
					if ((Object)(object)currentVoiceChatAudioSource != (Object)null)
					{
						currentVoiceChatAudioSource.spatialBlend = 0f;
					}
					player.currentVoiceChatIngameSettings.set2D = true;
					player.voicePlayerState.Volume = 1f;
				}
				else
				{
					if ((Object)(object)currentVoiceChatAudioSource != (Object)null)
					{
						currentVoiceChatAudioSource.spatialBlend = 1f;
					}
					player.currentVoiceChatIngameSettings.set2D = false;
					player.voicePlayerState.Volume = 0f;
				}
			}
		}

		private void SetNextTargetPlayer(int direction)
		{
			List<PlayerControllerB> alivePlayers = GetAlivePlayers();
			if (alivePlayers.Count == 0)
			{
				SetCurrentTargetToHost();
				ControlCompanyPlugin.Instance.logger.LogMessage((object)"Alive player count is zero");
			}
			else
			{
				currentTargetIndex += direction;
				if (currentTargetIndex >= alivePlayers.Count)
				{
					currentTargetIndex = 0;
				}
				else if (currentTargetIndex < 0)
				{
					currentTargetIndex = alivePlayers.Count - 1;
				}
				currentTargetIndex = Math.Min(Math.Max(0, currentTargetIndex), alivePlayers.Count - 1);
				currentTarget = alivePlayers[currentTargetIndex];
			}
			ControlCompanyPlugin.Instance.logger.LogMessage((object)$"Current target index: {currentTargetIndex}");
			ControlCompanyPlugin.Instance.logger.LogMessage((object)("Setting next target to: " + currentTarget?.playerUsername));
		}

		public void SetCurrentTargetToHost()
		{
			currentTargetIndex = 0;
			currentTarget = GetHostPlayer();
			ControlCompanyPlugin.Instance.logger.LogMessage((object)"Setting next target to host");
		}

		public void StartOfRoundInitialization()
		{
			gameStartedTime = 0f;
			SetCurrentTargetToHost();
			ResetToDefault();
			ControlCompanyPlugin.Instance.logger.LogMessage((object)"Start of round initialization completed.");
		}

		public void EndOfRoundCleanUp()
		{
			ResetToDefault();
			ControlCompanyPlugin.Instance.logger.LogMessage((object)"End of round clean up completed.");
		}

		private void ResetToDefault()
		{
			GetHostPlayer().isTypingChat = false;
			currentMode = Mode.HOST;
			if ((Object)(object)ghost != (Object)null)
			{
				Object.Destroy((Object)(object)ghost);
				ghost = null;
			}
			if ((Object)(object)currentControlledEnemy != (Object)null)
			{
				currentControlledEnemy.DestroyAndCleanUp();
			}
			EnableHostPlayer(enable: true);
			ControlCompanyPlugin.Instance.logger.LogMessage((object)"Reset to default.");
		}

		public PlayerControllerB GetHostPlayer()
		{
			return RoundManager.Instance.playersManager.allPlayerObjects[0].GetComponentInChildren<PlayerControllerB>();
		}

		public List<PlayerControllerB> GetDeadPlayers()
		{
			return (from player in GetAllPlayers()
				where player.isPlayerDead
				select player).ToList();
		}

		public List<PlayerControllerB> GetAlivePlayers()
		{
			return (from player in GetAllPlayers()
				where !player.isPlayerDead
				select player).ToList();
		}

		public List<PlayerControllerB> GetAllPlayers()
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			GameObject[] allPlayerObjects = RoundManager.Instance.playersManager.allPlayerObjects;
			for (int i = 0; i < allPlayerObjects.Length; i++)
			{
				PlayerControllerB componentInChildren = allPlayerObjects[i].GetComponentInChildren<PlayerControllerB>();
				if ((Object)(object)componentInChildren != (Object)null && componentInChildren.isPlayerControlled)
				{
					list.Add(componentInChildren);
				}
			}
			return list;
		}

		public bool DoesCurrentLevelExist()
		{
			return (Object)(object)GetCurrentLevel() != (Object)null;
		}

		public bool IsGameStarted()
		{
			if ((Object)(object)RoundManager.Instance != (Object)null && (Object)(object)RoundManager.Instance.currentLevel != (Object)null && (Object)(object)GameNetworkManager.Instance != (Object)null && GameNetworkManager.Instance.gameHasStarted && (Object)(object)StartOfRound.Instance != (Object)null)
			{
				return !StartOfRound.Instance.inShipPhase;
			}
			return false;
		}

		public SelectableLevel GetCurrentLevel()
		{
			return RoundManager.Instance.currentLevel;
		}

		public StartOfRound GetPlayersManager()
		{
			return RoundManager.Instance.playersManager;
		}

		private bool IsHost()
		{
			return ((NetworkBehaviour)RoundManager.Instance).IsHost;
		}

		public List<SpawnableItemWithRarity> GetSpawnableScraps()
		{
			return GetCurrentLevel().spawnableScrap;
		}

		public List<SpawnableEnemyWithRarity> GetSpawnableEnemies(bool isIndoor)
		{
			if (isIndoor)
			{
				return GetSpawnableIndoorEnemies();
			}
			return GetSpawnableOutdoorEnemies();
		}

		public List<SpawnableEnemyWithRarity> GetSpawnableIndoorEnemies()
		{
			if (!allowAllEnemies)
			{
				return GetAllowListedIndoorEnemies();
			}
			return GetIndoorEnemyList();
		}

		public List<SpawnableEnemyWithRarity> GetAllowListedIndoorEnemies()
		{
			return GetIndoorEnemyList().Where(delegate(SpawnableEnemyWithRarity enemy)
			{
				EnemyAI componentInChildren = enemy.enemyType.enemyPrefab.GetComponentInChildren<EnemyAI>();
				return !((Object)(object)componentInChildren == (Object)null) && componentInChildren.IsEnemyAllowlisted();
			}).ToList();
		}

		public List<SpawnableEnemyWithRarity> GetIndoorEnemyList()
		{
			return GetCurrentLevel().Enemies;
		}

		public List<SpawnableEnemyWithRarity> GetSpawnableOutdoorEnemies()
		{
			if (!allowAllEnemies)
			{
				return GetAllowListedOutdoorEnemies();
			}
			return GetOutdoorEnemyList();
		}

		public List<SpawnableEnemyWithRarity> GetAllowListedOutdoorEnemies()
		{
			return GetOutdoorEnemyList().Where(delegate(SpawnableEnemyWithRarity enemy)
			{
				EnemyAI componentInChildren = enemy.enemyType.enemyPrefab.GetComponentInChildren<EnemyAI>();
				return !((Object)(object)componentInChildren == (Object)null) && componentInChildren.IsEnemyAllowlisted();
			}).ToList();
		}

		public List<SpawnableEnemyWithRarity> GetOutdoorEnemyList()
		{
			return GetCurrentLevel().OutsideEnemies;
		}

		private GameObject SpawnScrap(SpawnableItemWithRarity scrap, Vector3 position)
		{
			//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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(scrap.spawnableItem.spawnPrefab, position, Quaternion.identity);
			GrabbableObject componentInChildren = obj.GetComponentInChildren<GrabbableObject>();
			((Component)componentInChildren).transform.rotation = Quaternion.Euler(componentInChildren.itemProperties.restingRotation);
			obj.GetComponentInChildren<NetworkObject>().Spawn(true);
			return obj;
		}

		private GameObject SpawnEnemy(SpawnableEnemyWithRarity enemyWithRarity, Vector3 position)
		{
			//IL_000b: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(enemyWithRarity.enemyType.enemyPrefab, position + new Vector3(0f, 0.5f, 0f), Quaternion.identity);
			obj.GetComponentInChildren<NetworkObject>().Spawn(true);
			return obj;
		}

		private EnemyController SpawnControllableEnemy(SpawnableEnemyWithRarity enemyWithRarity, Vector3 position, Quaternion rotation)
		{
			//IL_000b: 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_0025: 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_0047: Expected O, but got Unknown
			//IL_004d: 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_0062: 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)
			GameObject val = Object.Instantiate<GameObject>(enemyWithRarity.enemyType.enemyPrefab, position + new Vector3(0f, 0.5f, 0f), Quaternion.identity);
			val.GetComponentInChildren<NetworkObject>().Spawn(true);
			GameObject val2 = new GameObject("enemy_controller");
			val2.transform.position = position + new Vector3(0f, 0.5f, 0f);
			val2.transform.rotation = rotation;
			EnemyAI componentInChildren = val.GetComponentInChildren<EnemyAI>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				throw new Exception("Enemy AI is null, cannot spawn enemy");
			}
			EnemyController andAttachEnemyController = componentInChildren.GetAndAttachEnemyController(val2);
			andAttachEnemyController.InitializeEnemyController(GetHostPlayer().playerActions, val);
			andAttachEnemyController.EnableLight(IsTargetInside());
			return andAttachEnemyController;
		}

		private DissonanceComms GetMic()
		{
			return StartOfRound.Instance.voiceChatModule;
		}

		private void ForceMicPushToTalk()
		{
			IngamePlayerSettings.Instance.settings.pushToTalk = true;
		}

		private void ResetMicPushToTalk()
		{
			IngamePlayerSettings.Instance.settings.pushToTalk = initialMicPushToTalkSetting;
		}
	}
	internal class DoorOpener : MonoBehaviour
	{
		public void OpenDoor(float range)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, range);
			for (int i = 0; i < array.Length; i++)
			{
				DoorLock componentInChildren = ((Component)array[i]).GetComponentInChildren<DoorLock>();
				if ((Object)(object)componentInChildren != (Object)null && !componentInChildren.GetFieldValue<bool>("isDoorOpened"))
				{
					if (componentInChildren.isLocked)
					{
						componentInChildren.UnlockDoorServerRpc();
					}
					componentInChildren.OpenDoorAsEnemyServerRpc();
					((Component)componentInChildren).gameObject.GetComponent<AnimatedObjectTrigger>().TriggerAnimationNonPlayer(false, true, false);
					ControlCompanyPlugin.Instance.logger.LogMessage((object)"Opened door");
				}
			}
		}
	}
	internal class EnemyController : CustomPlayerController
	{
		protected GameObject enemyGameObject;

		private EnemyAI enemyAI;

		private NavMeshAgent enemyAIAgent;

		private float originalAgentAngularSpeed;

		private float originalAgentSpeed;

		private float rotationSpeed = 5f;

		protected bool isAIControlled;

		protected bool controlEnemyRotation;

		protected bool controlEnemyMovement = true;

		protected bool lockEnemyRotationInput;

		public bool IsAIControlled => isAIControlled;

		public EnemyAI EnemyAI => enemyAI;

		public virtual void InitializeEnemyController(PlayerActions playerActions, GameObject enemyGameObject)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!isInitialized)
			{
				Initialize(playerActions, CameraMode.THIRD_PERSON);
				enemyAI = GetEnemyAIFromEnemyGameObject(enemyGameObject);
				if ((Object)(object)enemyAI == (Object)null)
				{
					throw new Exception("Enemy gameobject does not have EnemyAI script attacked.");
				}
				canJump = false;
				((Component)enemyAI).gameObject.LogLayer();
				enemyGameObject.transform.position = ((Component)this).transform.position;
				enemyGameObject.transform.rotation = ((Component)this).transform.rotation;
				this.enemyGameObject = enemyGameObject;
				enemyAIAgent = enemyGameObject.GetComponentInChildren<NavMeshAgent>();
				originalAgentAngularSpeed = enemyAIAgent.angularSpeed;
				originalAgentSpeed = enemyAIAgent.speed;
				ConfigureEnemyAttributes(enemyAI);
				EnableAIControl(enabled: false);
			}
		}

		protected EnemyAI GetEnemyAIFromEnemyGameObject(GameObject enemyObj)
		{
			return enemyObj.GetComponentInChildren<EnemyAI>();
		}

		private void ConfigureEnemyAttributes(EnemyAI enemyAI)
		{
			EnemyAttributes enemyAttributes = enemyAI.GetEnemyAttributes();
			base.WalkSpeed = enemyAttributes.WalkSpeed;
			base.RunSpeed = enemyAttributes.RunSpeed;
			SetCamDistance(enemyAttributes.CamDistance);
			SetCamHeight(enemyAttributes.CamHeight);
			controlEnemyRotation = enemyAttributes.PlayerControlsRotation;
			controlEnemyMovement = true;
		}

		protected override void Update()
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			if (!isInitialized)
			{
				return;
			}
			base.Update();
			if (!isAIControlled)
			{
				if (!enemyAI.isEnemyDead)
				{
					if (controlEnemyMovement)
					{
						enemyGameObject.transform.position = ((Component)this).transform.position;
					}
					if (controlEnemyRotation && !lockEnemyRotationInput)
					{
						enemyGameObject.transform.rotation = ((Component)this).transform.rotation;
					}
				}
			}
			else
			{
				((Component)this).transform.position = enemyGameObject.transform.position;
			}
		}

		public void SetLockEnemyRotation(bool lockEnemyRotationInput)
		{
			this.lockEnemyRotationInput = lockEnemyRotationInput;
		}

		public virtual void UsePrimarySkill()
		{
			CheckInitialized();
			_ = isAIControlled;
		}

		public virtual void ReleasePrimarySkill()
		{
			CheckInitialized();
			_ = isAIControlled;
		}

		public virtual void UseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled)
			{
				enemyAI.SwitchToBehaviourState(1);
			}
		}

		public virtual void ReleaseSecondarySkill()
		{
			CheckInitialized();
			_ = isAIControlled;
		}

		public void SwitchAIState(int stateIndex)
		{
			CheckInitialized();
			if (!isAIControlled)
			{
				enemyAI.SwitchToBehaviourState(stateIndex);
			}
		}

		protected virtual void EnableAIControl(bool enabled)
		{
			CheckInitialized();
			isAIControlled = enabled;
			ControlCompanyPlugin.Instance.logger.LogMessage((object)$"Enable AI control: {enabled}");
			if (IsAIControlled)
			{
				enemyAIAgent.angularSpeed = originalAgentAngularSpeed;
				enemyAIAgent.speed = originalAgentSpeed;
				enemyAIAgent.isStopped = false;
			}
			else
			{
				enemyAI.ChangeOwnershipOfEnemy(ControlCenter.Instance.GetHostPlayer().actualClientId);
				enemyAIAgent.angularSpeed = 0f;
				enemyAIAgent.speed = 0f;
				enemyAIAgent.isStopped = true;
				((Component)this).transform.SetParent((Transform)null);
			}
			canMove = !isAIControlled;
		}

		public void ToggleAIControl()
		{
			CheckInitialized();
			isAIControlled = !isAIControlled;
			EnableAIControl(isAIControlled);
		}

		public virtual void DestroyAndCleanUp()
		{
			if (!enemyAI.isEnemyDead)
			{
				Object.Destroy((Object)(object)enemyGameObject);
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		public virtual string GetPrimarySkillName()
		{
			return "";
		}

		public virtual string GetSecondarySkillName()
		{
			return "Secondary Skill";
		}

		protected void CheckInitialized()
		{
			if (!isInitialized)
			{
				throw new Exception("Not initialized yet.");
			}
		}
	}
	internal class CustomPlayerController : MonoBehaviour
	{
		public enum CameraMode
		{
			THIRD_PERSON,
			FIRST_PERSON
		}

		protected bool isInitialized;

		protected bool hasControl;

		protected bool canMove;

		protected bool canRotate;

		protected bool canJump;

		protected CameraMode camMode;

		protected CharacterController characterController;

		protected GameObject cameraGameObjectParent;

		protected GameObject cameraGameObject;

		protected Camera camera;

		protected Light light;

		protected PlayerActions playerActions;

		protected DoorOpener doorOpener;

		private float runSpeed = 9f;

		private float walkSpeed = 7f;

		private float camDistance = -3.5f;

		private float camHeight = 2f;

		private float gravity = -20f;

		private float jumpHeight = 4.5f;

		private float currentYVelocity;

		private HashSet<int> seenLayers = new HashSet<int>();

		public float RunSpeed
		{
			get
			{
				return runSpeed;
			}
			set
			{
				runSpeed = value;
			}
		}

		public float WalkSpeed
		{
			get
			{
				return walkSpeed;
			}
			set
			{
				walkSpeed = value;
			}
		}

		public float Gravity
		{
			get
			{
				return gravity;
			}
			set
			{
				gravity = value;
			}
		}

		public void Initialize(PlayerActions playerActions, CameraMode camMode)
		{
			if (!isInitialized)
			{
				this.playerActions = playerActions;
				this.camMode = camMode;
				characterController = InitializeCharacterController();
				camera = InitializeCamera();
				light = InitializeLight(((Component)camera).gameObject);
				doorOpener = ((Component)this).gameObject.AddComponent<DoorOpener>();
				EnableControl(enable: true);
				isInitialized = true;
			}
		}

		public void EnableLight(bool enable)
		{
			((Behaviour)light).enabled = enable;
		}

		public void EnableControl(bool enable)
		{
			hasControl = enable;
			canMove = enable;
			canRotate = enable;
			canJump = enable;
		}

		public bool IsMoving()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 velocity = characterController.velocity;
			return ((Vector3)(ref velocity)).sqrMagnitude > 0f;
		}

		public void SetCamHeight(float camHeight)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			this.camHeight = camHeight;
			cameraGameObjectParent.transform.localPosition = new Vector3(0f, camHeight, 0f);
		}

		public void SetCamDistance(float camDistance)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			this.camDistance = camDistance;
			cameraGameObject.transform.localPosition = new Vector3(0f, 0f, (camMode == CameraMode.THIRD_PERSON) ? camDistance : 0f);
		}

		protected virtual void Update()
		{
			if (isInitialized && hasControl)
			{
				if (canMove)
				{
					Move();
				}
				if (canRotate)
				{
					Rotate();
				}
				if (((ButtonControl)InputKeys.CONTROLLER_USE_KEY).wasPressedThisFrame)
				{
					doorOpener.OpenDoor(3f);
				}
			}
		}

		protected virtual void Move()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			MovementActions movement = playerActions.Movement;
			bool flag = ((MovementActions)(ref movement)).Sprint.IsInProgress();
			movement = playerActions.Movement;
			Vector3 val = Vector2.op_Implicit(((MovementActions)(ref movement)).Move.ReadValue<Vector2>());
			Vector3 val2 = ((Component)this).transform.right * val.x;
			Vector3 val3 = ((Component)this).transform.forward * val.y;
			bool isGrounded = characterController.isGrounded;
			if (isGrounded && currentYVelocity < 0f)
			{
				currentYVelocity = 0f;
			}
			if (canJump && isGrounded && ((ButtonControl)InputKeys.CONTROLLER_JUMP_KEY).wasPressedThisFrame)
			{
				currentYVelocity += Mathf.Sqrt(jumpHeight * (0f - gravity));
			}
			currentYVelocity += gravity * Time.deltaTime;
			characterController.Move(((val2 + val3) * (flag ? runSpeed : walkSpeed) + new Vector3(0f, currentYVelocity, 0f)) * Time.deltaTime);
		}

		protected virtual void Rotate()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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)
			//IL_001d: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			MovementActions movement = 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)this).transform.Rotate(new Vector3(0f, val.x, 0f));
			cameraGameObjectParent.transform.Rotate(new Vector3(0f - val.y, 0f, 0f));
		}

		private Light InitializeLight(GameObject lightParent)
		{
			//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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("controller_light");
			val.transform.SetParent(lightParent.transform);
			val.transform.localPosition = new Vector3(0f, 0.5f, 0f);
			val.transform.localRotation = Quaternion.identity;
			Light obj = val.AddComponent<Light>();
			obj.range = 15f;
			obj.intensity = 250f;
			obj.cullingMask = -1;
			return obj;
		}

		private CharacterController InitializeCharacterController()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			CharacterController obj = ((Component)this).gameObject.AddComponent<CharacterController>();
			((Collider)obj).excludeLayers = LayerMask.op_Implicit(LayerMask.op_Implicit(Constants.PLAYER_LOS_LAYER) | LayerMask.op_Implicit(Constants.ITERACTABLE_OBJ_LAYER) | LayerMask.op_Implicit(Constants.ENEMIES_LAYER) | LayerMask.op_Implicit(Constants.PROPS_LAYER) | LayerMask.op_Implicit(Constants.PLAYER_RAGDOLL_LAYER));
			obj.center = new Vector3(0f, 0.55f, 0f);
			obj.height = 0.4f;
			obj.slopeLimit = 60f;
			obj.stepOffset = 0.4f;
			return obj;
		}

		private Camera InitializeCamera()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0057: Expected O, but got Unknown
			//IL_006e: 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)
			GameObject val = new GameObject("controller_cam_parent");
			val.transform.SetParent(((Component)this).transform);
			val.transform.localRotation = Quaternion.identity;
			val.transform.localPosition = new Vector3(0f, camHeight, 0f);
			GameObject val2 = new GameObject("controller_cam");
			val2.transform.SetParent(val.transform);
			val2.transform.localRotation = Quaternion.identity;
			val2.transform.localPosition = new Vector3(0f, 0f, (camMode == CameraMode.THIRD_PERSON) ? camDistance : 0f);
			Camera obj = val2.AddComponent<Camera>();
			val2.AddComponent<AudioListener>();
			cameraGameObject = val2;
			cameraGameObjectParent = val;
			obj.cullingMask = ControlCenter.Instance.GetHostPlayer().gameplayCamera.cullingMask;
			return obj;
		}

		private void OnControllerColliderHit(ControllerColliderHit hit)
		{
			if (!seenLayers.Contains(hit.gameObject.layer))
			{
				hit.gameObject.LogLayer();
				seenLayers.Add(hit.gameObject.layer);
			}
		}
	}
}
namespace ControlCompany.Core.UI
{
	public class UIInstruction
	{
		public string InputKey { get; set; }

		public string ActionText { get; set; }
	}
	internal class UIManager : MonoBehaviour
	{
		private const float GUI_LABEL_HEIGHT = 36f;

		private const float GUI_LABEL_WIDTH = 750f;

		private const float GUI_PADDING = 32f;

		private const int GUI_FONT_SIZE = 28;

		private const FontStyle GUI_FONT_WEIGHT = 0;

		public static UIManager Instance;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		public void RenderNotHostLabel(string toggleUIKey)
		{
			//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_0016: 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_0026: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)3,
				fontSize = 24,
				fontStyle = (FontStyle)0
			};
			val.normal.textColor = Color.red;
			RenderTextTopLeftCorner("Not hosting. ControlCompany mod is disabled. Press " + toggleUIKey + " to hide.", 0f, val);
		}

		public void RenderEnemyControls(string primaryKey, string secondaryKey, string aiControlKey, string exitKey, EnemyController enemyController, PlayerControllerB hostPlayer)
		{
			string primarySkillName = enemyController.GetPrimarySkillName();
			string secondarySkillName = enemyController.GetSecondarySkillName();
			List<UIInstruction> list = new List<UIInstruction>();
			if (enemyController.IsAIControlled)
			{
				list.Add(new UIInstruction
				{
					InputKey = aiControlKey,
					ActionText = "Take control"
				});
			}
			else
			{
				if (!Utility.IsNullOrWhiteSpace(primarySkillName))
				{
					list.Add(new UIInstruction
					{
						InputKey = primaryKey,
						ActionText = primarySkillName
					});
				}
				if (!Utility.IsNullOrWhiteSpace(secondarySkillName))
				{
					list.Add(new UIInstruction
					{
						InputKey = secondaryKey,
						ActionText = secondarySkillName
					});
				}
				list.Add(new UIInstruction
				{
					InputKey = aiControlKey,
					ActionText = "AI control"
				});
			}
			list.Add(new UIInstruction
			{
				InputKey = exitKey,
				ActionText = "Exit"
			});
			RenderPlayerStatus(hostPlayer);
			float height = 0f;
			height = RenderEnemyStatus(enemyController, height);
			RenderEnemySkills(list, height);
		}

		public void RenderHostControls(string ghostModeKey, string cycleLeftKey, string cycleRightKey, PlayerControllerB currentTarget, bool isExtendedModeEnabled, string creditsKey, string entranceTeleportKey, string toggleUIKey)
		{
			List<UIInstruction> list = new List<UIInstruction>();
			list.Add(new UIInstruction
			{
				InputKey = ghostModeKey,
				ActionText = "Ghost mode"
			});
			list.Add(new UIInstruction
			{
				InputKey = $"{cycleLeftKey}/{cycleRightKey}",
				ActionText = "Change target"
			});
			list.Add(new UIInstruction
			{
				InputKey = toggleUIKey,
				ActionText = "Hide UI"
			});
			if (isExtendedModeEnabled)
			{
				list.Add(new UIInstruction
				{
					InputKey = creditsKey,
					ActionText = "Give credits"
				});
				list.Add(new UIInstruction
				{
					InputKey = entranceTeleportKey,
					ActionText = "Teleport to entrance"
				});
			}
			RenderHostControlList(list, currentTarget);
		}

		public void RenderGhostControls(List<string> enemySpawnKeys, string exitKey, List<SpawnableEnemyWithRarity> enemies, List<SpawnableItemWithRarity> scraps, PlayerControllerB hostPlayer, bool scrapSpawnMode)
		{
			List<UIInstruction> list = new List<UIInstruction>();
			if (!scrapSpawnMode)
			{
				for (int i = 0; i < enemies.Count && i < enemySpawnKeys.Count; i++)
				{
					EnemyAI componentInChildren = enemies[i].enemyType.enemyPrefab.GetComponentInChildren<EnemyAI>();
					list.Add(new UIInstruction
					{
						InputKey = enemySpawnKeys[i],
						ActionText = $"Control {(((Object)(object)componentInChildren == (Object)null) ? enemies[i].enemyType.enemyName : componentInChildren.GetEnemyName())}"
					});
				}
			}
			else
			{
				for (int j = 0; j < scraps.Count && j < enemySpawnKeys.Count; j++)
				{
					list.Add(new UIInstruction
					{
						InputKey = enemySpawnKeys[j],
						ActionText = $"Spawn {scraps[j].spawnableItem.itemName}"
					});
				}
			}
			list.Add(new UIInstruction
			{
				InputKey = exitKey,
				ActionText = "Exit"
			});
			RenderPlayerStatus(hostPlayer);
			RenderGhostControlList(list);
		}

		private void RenderGhostControlList(List<UIInstruction> ghostControls)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_002f: Expected O, but got Unknown
			if (ghostControls.Count <= 0)
			{
				return;
			}
			GUIStyle style = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)5,
				fontSize = 28,
				fontStyle = (FontStyle)0
			};
			float num = 0f;
			foreach (UIInstruction ghostControl in ghostControls)
			{
				RenderTextTopRightCorner($"{ghostControl.InputKey}: {ghostControl.ActionText}", num, style);
				num += 36f;
			}
		}

		private float RenderMicStatus(float height, PlayerControllerB hostPlayer)
		{
			//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_0016: 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_0026: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)3,
				fontSize = 28,
				fontStyle = (FontStyle)0
			};
			float num = height;
			if (IngamePlayerSettings.Instance.settings.micEnabled)
			{
				if (!StartOfRound.Instance.voiceChatModule.IsMuted)
				{
					val.normal.textColor = Color.green;
					RenderTextTopLeftCorner(string.Format("{0} mic enabled", hostPlayer.isPlayerDead ? "Dead" : "Player"), num, val);
				}
				else
				{
					val.normal.textColor = Color.red;
					RenderTextTopLeftCorner(string.Format("{0} mic disabled (push to talk)", hostPlayer.isPlayerDead ? "Dead" : "Player"), num, val);
				}
				num += 36f;
			}
			return num;
		}

		private float RenderPlayerStatus(PlayerControllerB hostPlayer)
		{
			//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_0016: 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_0026: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)3,
				fontSize = 28,
				fontStyle = (FontStyle)0
			};
			if (hostPlayer.isPlayerDead)
			{
				val.normal.textColor = Color.red;
			}
			else
			{
				val.normal.textColor = Color.green;
			}
			float num = 0f;
			RenderTextTopLeftCorner(string.Format("Player status: {0}", hostPlayer.isPlayerDead ? "Dead" : "Alive"), num, val);
			num += 36f;
			if (!hostPlayer.isPlayerDead)
			{
				GUIStyle val2 = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					fontSize = 28,
					fontStyle = (FontStyle)0
				};
				bool flag = !HostIsNearOtherPlayers(hostPlayer);
				if (flag)
				{
					val2.normal.textColor = Color.green;
				}
				else
				{
					val2.normal.textColor = Color.red;
				}
				RenderTextTopLeftCorner(string.Format("Player proximity: {0}", flag ? "Alone" : "Near others"), num, val2);
				num += 36f;
			}
			return num + RenderMicStatus(num, hostPlayer);
		}

		private void RenderHostControlList(List<UIInstruction> hostControls, PlayerControllerB currentTarget)
		{
			//IL_0016: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (hostControls.Count <= 0)
			{
				return;
			}
			GUIStyle style = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)5,
				fontSize = 28,
				fontStyle = (FontStyle)0
			};
			float num = 0f;
			if ((Object)(object)currentTarget != (Object)null)
			{
				RenderTextTopRightCorner($"Spawn target: {currentTarget.playerUsername}", num, style);
				num += 36f;
			}
			foreach (UIInstruction hostControl in hostControls)
			{
				RenderTextTopRightCorner($"{hostControl.InputKey}: {hostControl.ActionText}", num, style);
				num += 36f;
			}
		}

		private float RenderEnemyStatus(EnemyController enemyController, float height)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			float num = height;
			if (enemyController.IsAIControlled)
			{
				GUIStyle val = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)5,
					fontSize = 28,
					fontStyle = (FontStyle)0
				};
				val.normal.textColor = Color.red;
				RenderTextTopRightCorner("AI controlled", num, val);
				num += 36f;
			}
			return num;
		}

		private float RenderEnemySkills(List<UIInstruction> playerEnemyControls, float height)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			//IL_0031: Expected O, but got Unknown
			float num = height;
			if (playerEnemyControls.Count > 0)
			{
				GUIStyle style = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)5,
					fontSize = 28,
					fontStyle = (FontStyle)0
				};
				foreach (UIInstruction playerEnemyControl in playerEnemyControls)
				{
					RenderTextTopRightCorner($"{playerEnemyControl.InputKey}: {playerEnemyControl.ActionText}", num, style);
					num += 36f;
				}
			}
			return num;
		}

		private void RenderTextMiddle(string text, float yPos, GUIStyle style)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(new Rect((float)Screen.width / 2f - 375f, yPos + 32f, 750f, 36f), text, style);
		}

		private void RenderTextTopRightCorner(string text, float yPos, GUIStyle style)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(new Rect((float)Screen.width - 750f - 32f, yPos + 32f, 750f, 36f), text, style);
		}

		private void RenderTextTopLeftCorner(string text, float yPos, GUIStyle style)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(new Rect(32f, yPos + 32f, 750f, 36f), text, style);
		}

		private bool HostIsNearOtherPlayers(PlayerControllerB hostPlayer)
		{
			return (bool)hostPlayer.Call("NearOtherPlayers", hostPlayer, 17f);
		}
	}
}
namespace ControlCompany.Core.Input
{
	public static class InputKeys
	{
		public static KeyControl EXIT_KEY = Keyboard.current.escapeKey;

		public static KeyControl EXTENDED_MODE_KEY = Keyboard.current.digit0Key;

		public static KeyControl TOGGLE_UI_KEY = Keyboard.current.uKey;

		public static KeyControl HOST_GHOST_MODE_KEY = Keyboard.current.f1Key;

		public static KeyControl HOST_CYCLE_PLAYER_TARGET_LIST_KEY_LEFT = Keyboard.current.oKey;

		public static KeyControl HOST_CYCLE_PLAYER_TARGET_LIST_KEY_RIGHT = Keyboard.current.pKey;

		public static KeyControl HOST_GIVE_CREDITS_KEY = Keyboard.current.digit8Key;

		public static KeyControl HOST_TELEPORT_TO_ENTRANCE_KEY = Keyboard.current.digit9Key;

		public static KeyControl GHOST_SPAWN_ENEMY_1 = Keyboard.current.f1Key;

		public static KeyControl GHOST_SPAWN_ENEMY_2 = Keyboard.current.f2Key;

		public static KeyControl GHOST_SPAWN_ENEMY_3 = Keyboard.current.f3Key;

		public static KeyControl GHOST_SPAWN_ENEMY_4 = Keyboard.current.f4Key;

		public static KeyControl GHOST_SPAWN_ENEMY_5 = Keyboard.current.f5Key;

		public static KeyControl GHOST_SPAWN_ENEMY_6 = Keyboard.current.f6Key;

		public static KeyControl GHOST_SPAWN_ENEMY_7 = Keyboard.current.f7Key;

		public static KeyControl GHOST_SPAWN_ENEMY_8 = Keyboard.current.f8Key;

		public static KeyControl GHOST_SPAWN_ENEMY_9 = Keyboard.current.f9Key;

		public static KeyControl GHOST_SPAWN_ENEMY_10 = Keyboard.current.f10Key;

		public static KeyControl GHOST_SPAWN_ENEMY_11 = Keyboard.current.f11Key;

		public static KeyControl GHOST_SPAWN_ENEMY_12 = Keyboard.current.f12Key;

		public static List<KeyControl> GHOST_SPAWN_ENEMY_KEYS = new List<KeyControl>();

		public static KeyControl ENEMY_TOGGLE_AI_KEY = Keyboard.current.f1Key;

		public static ButtonControl ENEMY_PRIMARY_SKILL_BUTTON = Mouse.current.leftButton;

		public static ButtonControl ENEMY_SECONDARY_SKILL_BUTTON = Mouse.current.rightButton;

		public static KeyControl LOCK_ENEMY_ROTATION_KEY = Keyboard.current.leftAltKey;

		public static KeyControl CONTROLLER_USE_KEY = Keyboard.current.eKey;

		public static KeyControl CONTROLLER_JUMP_KEY = Keyboard.current.spaceKey;
	}
}
namespace ControlCompany.Core.Extentions
{
	public static class ExtensionMethods
	{
		public static T GetFieldValue<T>(this object obj, string name)
		{
			return (T)(obj.GetType().GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj));
		}

		public static void SetFieldValue<T>(this object obj, string method, T value)
		{
			obj.GetType().GetField(method, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetField | BindingFlags.SetProperty)?.SetValue(obj, value);
		}

		public static object Call(this object o, string methodName, params object[] args)
		{
			MethodInfo method = o.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic);
			if (method != null)
			{
				return method.Invoke(o, args);
			}
			return null;
		}

		public static TValue GetValueOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue)
		{
			if (dictionary.TryGetValue(key, out var value))
			{
				return value;
			}
			return defaultValue;
		}

		public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunksize)
		{
			while (source.Any())
			{
				yield return source.Take(chunksize);
				source = source.Skip(chunksize);
			}
		}

		public static void LogLayer(this GameObject gameObject)
		{
			ControlCompanyPlugin.Instance.logger.LogMessage((object)$"Enemy layer ({LayerMask.LayerToName(gameObject.layer)}): {gameObject.layer}");
		}

		public static void LogGameObjectName(this GameObject gameObject)
		{
			ControlCompanyPlugin.Instance.logger.LogMessage((object)string.Format("GameObject name: {0}, parent: {1}", ((Object)gameObject).name, ((Object)(object)gameObject.transform.parent != (Object)null) ? ((Object)gameObject.transform.parent).name : "null"));
		}

		public static void LogAllComponents(this GameObject gameObject)
		{
			Component[] components = gameObject.GetComponents<Component>();
			foreach (Component val in components)
			{
				_ = $"GameObject ({((Object)gameObject).name}) component: {((Object)val).name}";
			}
		}

		public static void LogPosition(this GameObject gameObject)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			ControlCompanyPlugin.Instance.logger.LogMessage((object)$"GameObject ({((Object)gameObject).name}) position: {gameObject.transform.position}, local position: {gameObject.transform.localPosition}");
		}
	}
}
namespace ControlCompany.Core.Enemy
{
	internal class CentipedeEnemyController : EnemyController
	{
		private CentipedeAI centipedeAI;

		public override void InitializeEnemyController(PlayerActions playerActions, GameObject enemyGameObject)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			centipedeAI = (CentipedeAI)GetEnemyAIFromEnemyGameObject(enemyGameObject);
			base.InitializeEnemyController(playerActions, enemyGameObject);
		}

		protected override void Update()
		{
			base.Update();
			bool flag = IsClingingToSomething();
			controlEnemyRotation = !flag;
			controlEnemyMovement = !flag;
		}

		protected override void Move()
		{
			if (!IsClingingToSomething())
			{
				base.Move();
			}
		}

		public override void UsePrimarySkill()
		{
			CheckInitialized();
			if (!isAIControlled && ((EnemyAI)centipedeAI).currentBehaviourStateIndex == 1)
			{
				SwitchAIState(2);
			}
		}

		public override void UseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled && !IsClingingToSomething())
			{
				centipedeAI.Call("RaycastToCeiling");
				SwitchAIState(1);
			}
		}

		public bool IsClingingToSomething()
		{
			if (!((Object)(object)centipedeAI.clingingToPlayer != (Object)null) && !((EnemyAI)centipedeAI).inSpecialAnimation && !centipedeAI.GetFieldValue<bool>("clingingToDeadBody") && !centipedeAI.GetFieldValue<bool>("clingingToCeiling") && !centipedeAI.GetFieldValue<bool>("startedCeilingAnimationCoroutine"))
			{
				return centipedeAI.GetFieldValue<bool>("inDroppingOffPlayerAnim");
			}
			return true;
		}

		public override string GetPrimarySkillName()
		{
			return "Drop";
		}

		public override string GetSecondarySkillName()
		{
			return "Attach to ceiling";
		}
	}
	internal class FlowermanEnemyController : EnemyController
	{
		private FlowermanAI flowermanAI;

		private const int FLOWERMAN_DEFAULT_MODE = 0;

		private const int FLOWERMAN_STAND_MODE = 1;

		public override void InitializeEnemyController(PlayerActions playerActions, GameObject enemyGameObject)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			flowermanAI = (FlowermanAI)GetEnemyAIFromEnemyGameObject(enemyGameObject);
			base.InitializeEnemyController(playerActions, enemyGameObject);
		}

		public override void UseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled)
			{
				((EnemyAI)flowermanAI).SwitchToBehaviourState(1);
			}
		}

		public override void ReleaseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled)
			{
				((EnemyAI)flowermanAI).SwitchToBehaviourState(0);
			}
		}

		public override void UsePrimarySkill()
		{
			CheckInitialized();
			if (!isAIControlled && flowermanAI.carryingPlayerBody)
			{
				flowermanAI.Call("DropPlayerBody");
				flowermanAI.DropPlayerBodyServerRpc();
			}
		}

		public override string GetPrimarySkillName()
		{
			if (!flowermanAI.carryingPlayerBody)
			{
				return "";
			}
			return "Drop body";
		}

		public override string GetSecondarySkillName()
		{
			return "";
		}
	}
	internal class ForestGiantEnemyController : EnemyController
	{
		private ForestGiantAI forestGiantAI;

		private const int FOREST_GIANT_DEFAULT_MODE = 0;

		private const int FOREST_GIANT_CHASE_MODE = 1;

		public override void InitializeEnemyController(PlayerActions playerActions, GameObject enemyGameObject)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			forestGiantAI = (ForestGiantAI)GetEnemyAIFromEnemyGameObject(enemyGameObject);
			base.InitializeEnemyController(playerActions, enemyGameObject);
		}

		protected override void Update()
		{
			base.Update();
			bool flag = IsEatingPlayer();
			controlEnemyRotation = !flag;
			controlEnemyMovement = !flag;
		}

		protected override void Move()
		{
			if (!IsEatingPlayer())
			{
				base.Move();
			}
		}

		public override void UseSecondarySkill()
		{
			CheckInitialized();
			_ = isAIControlled;
		}

		public override void ReleaseSecondarySkill()
		{
			CheckInitialized();
			_ = isAIControlled;
		}

		public override string GetSecondarySkillName()
		{
			return "";
		}

		public bool IsEatingPlayer()
		{
			return forestGiantAI.GetFieldValue<bool>("inEatingPlayerAnimation");
		}
	}
	internal class HoardingBugEnemyController : EnemyController
	{
		private HoarderBugAI hoarderBugAI;

		private List<Type> allowedGrabbableItemUse = new List<Type>
		{
			typeof(ShotgunItem),
			typeof(NoisemakerProp),
			typeof(FlashlightItem)
		};

		private float grabRange = 1.5f;

		public override void InitializeEnemyController(PlayerActions playerActions, GameObject enemyGameObject)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			hoarderBugAI = (HoarderBugAI)GetEnemyAIFromEnemyGameObject(enemyGameObject);
			base.InitializeEnemyController(playerActions, enemyGameObject);
		}

		protected override void EnableAIControl(bool enabled)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (enabled)
			{
				hoarderBugAI.Call("ChooseNestPosition");
				((EnemyAI)hoarderBugAI).SwitchToBehaviourState(0);
			}
			else
			{
				hoarderBugAI.nestPosition = new Vector3(2000f, 2000f, 2000f);
			}
			base.EnableAIControl(enabled);
		}

		protected override void Update()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (isInitialized)
			{
				base.Update();
				if (!isAIControlled)
				{
					hoarderBugAI.nestPosition = new Vector3(2000f, 2000f, 2000f);
				}
			}
		}

		public override void UsePrimarySkill()
		{
			CheckInitialized();
			if (!isAIControlled && hoarderBugAI.heldItem != null)
			{
				UseHeldItem();
			}
		}

		public override void UseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled)
			{
				ControlCompanyPlugin.Instance.logger.LogMessage((object)"Using hoarder bug secondary");
				if (hoarderBugAI.heldItem == null)
				{
					GrabNearbyItem();
				}
				else
				{
					DropCurrentItem();
				}
			}
		}

		public void UseHeldItem()
		{
			//IL_003a: 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)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			GrabbableObject itemGrabbableObject = hoarderBugAI.heldItem.itemGrabbableObject;
			Type type = ((object)itemGrabbableObject).GetType();
			if (allowedGrabbableItemUse.Contains(type))
			{
				if (type == typeof(ShotgunItem))
				{
					ShotgunItem val = (ShotgunItem)itemGrabbableObject;
					val.gunShootAudio.volume = 0.15f;
					val.shotgunRayPoint = enemyGameObject.transform;
					val.ShootGunAndSync(false);
				}
				else
				{
					itemGrabbableObject.UseItemOnClient(true);
				}
			}
		}

		public void GrabNearbyItem()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (hoarderBugAI.heldItem != null)
			{
				return;
			}
			Collider[] array = Physics.OverlapSphere(enemyGameObject.transform.position, grabRange);
			for (int i = 0; i < array.Length; i++)
			{
				GrabbableObject componentInChildren = ((Component)array[i]).GetComponentInChildren<GrabbableObject>();
				if ((Object)(object)componentInChildren != (Object)null && hoarderBugAI.heldItem == null && (Object)(object)((Component)componentInChildren).GetComponent<NetworkObject>() != (Object)null)
				{
					hoarderBugAI.targetItem = componentInChildren;
					hoarderBugAI.Call("GrabTargetItemIfClose");
					break;
				}
			}
		}

		public void DropCurrentItem()
		{
			if (hoarderBugAI.heldItem != null)
			{
				hoarderBugAI.Call("DropItemAndCallDropRPC", ((Component)hoarderBugAI.heldItem.itemGrabbableObject).GetComponent<NetworkObject>(), false);
			}
		}

		public override string GetPrimarySkillName()
		{
			if (hoarderBugAI.heldItem == null || !allowedGrabbableItemUse.Contains(((object)hoarderBugAI.heldItem).GetType()))
			{
				return "";
			}
			return "Use item";
		}

		public override string GetSecondarySkillName()
		{
			if (hoarderBugAI.heldItem != null)
			{
				return "Drop item";
			}
			return "Grab item";
		}
	}
	internal class JesterEnemyController : EnemyController
	{
		private JesterAI jesterEnemyAI;

		private const int JESTER_DEFAULT_MODE = 0;

		private const int JESTER_CRANK_MODE_INDEX = 1;

		private const int JESTER_POP_OUT_INDEX = 2;

		private float initialWalkSpeed;

		private float initialRunSpeed;

		private bool initialControlRotation;

		public override void InitializeEnemyController(PlayerActions playerActions, GameObject enemyGameObject)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			jesterEnemyAI = (JesterAI)GetEnemyAIFromEnemyGameObject(enemyGameObject);
			base.InitializeEnemyController(playerActions, enemyGameObject);
			initialWalkSpeed = base.WalkSpeed;
			initialRunSpeed = base.RunSpeed;
			initialControlRotation = controlEnemyRotation;
		}

		protected override void Update()
		{
			base.Update();
			if (IsCranking())
			{
				controlEnemyMovement = false;
				controlEnemyRotation = false;
			}
			else if (IsPoppedOut() || IsInBox())
			{
				controlEnemyMovement = initialControlRotation;
				controlEnemyRotation = initialControlRotation;
			}
			if (IsPoppedOut())
			{
				base.WalkSpeed = 10f;
				base.RunSpeed = 15f;
			}
			else if (IsInBox())
			{
				base.WalkSpeed = initialWalkSpeed;
				base.RunSpeed = initialRunSpeed;
			}
		}

		public override void UsePrimarySkill()
		{
			CheckInitialized();
			if (!isAIControlled && !IsInBox())
			{
				ResetState();
			}
		}

		public override void UseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled && IsInBox())
			{
				Cranking();
			}
		}

		public override void ReleaseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled && IsCranking())
			{
				PopOut();
			}
		}

		protected override void Move()
		{
			if (!IsCranking())
			{
				base.Move();
			}
		}

		public override string GetPrimarySkillName()
		{
			return "Close box";
		}

		public override string GetSecondarySkillName()
		{
			return "(HOLD) Play music";
		}

		private void Cranking()
		{
			SwitchAIState(1);
		}

		private void PopOut()
		{
			SwitchAIState(2);
		}

		private void ResetState()
		{
			SwitchAIState(0);
		}

		private bool IsInBox()
		{
			return ((EnemyAI)jesterEnemyAI).currentBehaviourStateIndex == 0;
		}

		private bool IsCranking()
		{
			return ((EnemyAI)jesterEnemyAI).currentBehaviourStateIndex == 1;
		}

		private bool IsPoppedOut()
		{
			return ((EnemyAI)jesterEnemyAI).currentBehaviourStateIndex == 2;
		}
	}
	internal class MouthDogEnemyController : EnemyController
	{
		private MouthDogAI mouthDogAI;

		private const int MOUTH_DOG_LUNGE = 2;

		public override void InitializeEnemyController(PlayerActions playerActions, GameObject enemyGameObject)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			mouthDogAI = (MouthDogAI)GetEnemyAIFromEnemyGameObject(enemyGameObject);
			base.InitializeEnemyController(playerActions, enemyGameObject);
		}

		public override void UseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled && !IsLunging())
			{
				Lunge();
			}
		}

		public override string GetSecondarySkillName()
		{
			return "Lunge";
		}

		private void Lunge()
		{
			((EnemyAI)mouthDogAI).SwitchToBehaviourState(2);
		}

		private bool IsLunging()
		{
			return ((EnemyAI)mouthDogAI).currentBehaviourStateIndex == 2;
		}
	}
	internal class NutcrackerEnemyController : EnemyController
	{
		private NutcrackerEnemyAI nutcrackerEnemyAI;

		public override void InitializeEnemyController(PlayerActions playerActions, GameObject enemyGameObject)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			nutcrackerEnemyAI = (NutcrackerEnemyAI)GetEnemyAIFromEnemyGameObject(enemyGameObject);
			base.InitializeEnemyController(playerActions, enemyGameObject);
		}

		protected override void Update()
		{
			if (isInitialized)
			{
				base.Update();
				if (!isAIControlled && IsMoving() && ((EnemyAI)nutcrackerEnemyAI).currentBehaviourStateIndex != 0)
				{
					((EnemyAI)nutcrackerEnemyAI).SwitchToBehaviourState(0);
				}
			}
		}

		public override void UsePrimarySkill()
		{
			CheckInitialized();
			if (!isAIControlled && (Object)(object)nutcrackerEnemyAI.gun != (Object)null)
			{
				nutcrackerEnemyAI.gun.gunShootAudio.volume = 0.15f;
				nutcrackerEnemyAI.FireGunServerRpc();
			}
		}

		public override void UseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled)
			{
				SwitchAIState(1);
			}
		}

		public override void ReleaseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled)
			{
				SwitchAIState(0);
			}
		}

		public override void DestroyAndCleanUp()
		{
			if (!((EnemyAI)nutcrackerEnemyAI).isEnemyDead)
			{
				Object.Destroy((Object)(object)((Component)nutcrackerEnemyAI.gun).gameObject);
			}
			base.DestroyAndCleanUp();
		}

		public override string GetPrimarySkillName()
		{
			return "Fire";
		}

		public override string GetSecondarySkillName()
		{
			return "(HOLD) Sentry mode";
		}
	}
	internal class PufferEnemyController : EnemyController
	{
		private PufferAI pufferAI;

		public override void InitializeEnemyController(PlayerActions playerActions, GameObject enemyGameObject)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			pufferAI = (PufferAI)GetEnemyAIFromEnemyGameObject(enemyGameObject);
			base.InitializeEnemyController(playerActions, enemyGameObject);
		}

		public override void UsePrimarySkill()
		{
			CheckInitialized();
			if (!isAIControlled)
			{
				if (((EnemyAI)pufferAI).currentBehaviourStateIndex != 1)
				{
					SwitchAIState(1);
				}
				pufferAI.StompServerRpc();
			}
		}

		public override void UseSecondarySkill()
		{
			CheckInitialized();
			if (!isAIControlled)
			{
				if (((EnemyAI)pufferAI).currentBehaviourStateIndex != 1)
				{
					SwitchAIState(1);
				}
				pufferAI.ShakeTailServerRpc();
			}
		}

		public override string GetPrimarySkillName()
		{
			return "Stomp";
		}

		public override string GetSecondarySkillName()
		{
			return "Smoke";
		}
	}
}
namespace ControlCompany.Core.Config
{
	internal class ConfigManager : MonoBehaviour
	{
		public static ConfigManager Instance;

		private ConfigFile config;

		private bool isInitialized;

		private const string KEYBIND_CONFIG = "Keybinds";

		private const string KEYBIND_CONFIG_HOST_MODE = "Keybinds.PlayerMode";

		private const string KEYBIND_CONFIG_GHOST_MODE = "Keybinds.GhostMode";

		private const string KEYBIND_CONFIG_ENEMY_MODE = "Keybinds.MonsterMode";

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		public void Initialize(ConfigFile config)
		{
			if (!isInitialized)
			{
				this.config = config;
				isInitialized = true;
			}
		}

		public void LoadPlayerKeybinds()
		{
			if (config != null)
			{
				LoadKeysFromConfig(config);
			}
		}

		private void LoadKeysFromConfig(ConfigFile config)
		{
			ConfigEntry<string> keyEntry = config.Bind<string>("Keybinds", "extended_mode_key", "0", (ConfigDescription)null);
			ConfigEntry<string> keyEntry2 = config.Bind<string>("Keybinds", "exit_mode_key", "esc", (ConfigDescription)null);
			ConfigEntry<string> keyEntry3 = config.Bind<string>("Keybinds", "open_door", "e", (ConfigDescription)null);
			ConfigEntry<string> keyEntry4 = config.Bind<string>("Keybinds", "toggle_ui", "u", (ConfigDescription)null);
			InputKeys.CONTROLLER_USE_KEY = GetKeyControlFromConfig(keyEntry3, InputKeys.CONTROLLER_USE_KEY);
			InputKeys.EXTENDED_MODE_KEY = GetKeyControlFromConfig(keyEntry, InputKeys.EXTENDED_MODE_KEY);
			InputKeys.EXIT_KEY = GetKeyControlFromConfig(keyEntry2, InputKeys.EXIT_KEY);
			InputKeys.TOGGLE_UI_KEY = GetKeyControlFromConfig(keyEntry4, InputKeys.TOGGLE_UI_KEY);
			ConfigEntry<string> keyEntry5 = config.Bind<string>("Keybinds.PlayerMode", "ghost_mode_key", "f1", (ConfigDescription)null);
			ConfigEntry<string> keyEntry6 = config.Bind<string>("Keybinds.PlayerMode", "cycle_target_left_key", "o", (ConfigDescription)null);
			ConfigEntry<string> keyEntry7 = config.Bind<string>("Keybinds.PlayerMode", "cycle_target_right_key", "p", (ConfigDescription)null);
			InputKeys.HOST_GHOST_MODE_KEY = GetKeyControlFromConfig(keyEntry5, InputKeys.HOST_GHOST_MODE_KEY);
			InputKeys.HOST_CYCLE_PLAYER_TARGET_LIST_KEY_LEFT = GetKeyControlFromConfig(keyEntry6, InputKeys.HOST_CYCLE_PLAYER_TARGET_LIST_KEY_LEFT);
			InputKeys.HOST_CYCLE_PLAYER_TARGET_LIST_KEY_RIGHT = GetKeyControlFromConfig(keyEntry7, InputKeys.HOST_CYCLE_PLAYER_TARGET_LIST_KEY_RIGHT);
			ConfigEntry<string> keyEntry8 = config.Bind<string>("Keybinds.PlayerMode", "extended_teleport_to_entrance_key", "9", (ConfigDescription)null);
			InputKeys.HOST_TELEPORT_TO_ENTRANCE_KEY = GetKeyControlFromConfig(keyEntry8, InputKeys.HOST_TELEPORT_TO_ENTRANCE_KEY);
			ConfigEntry<string> keyEntry9 = config.Bind<string>("Keybinds.GhostMode", "jump", "space", (ConfigDescription)null);
			InputKeys.CONTROLLER_JUMP_KEY = GetKeyControlFromConfig(keyEntry9, InputKeys.CONTROLLER_JUMP_KEY);
			ConfigEntry<string> keyEntry10 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_1", "f1", (ConfigDescription)null);
			ConfigEntry<string> keyEntry11 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_2", "f2", (ConfigDescription)null);
			ConfigEntry<string> keyEntry12 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_3", "f3", (ConfigDescription)null);
			ConfigEntry<string> keyEntry13 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_4", "f4", (ConfigDescription)null);
			ConfigEntry<string> keyEntry14 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_5", "f5", (ConfigDescription)null);
			ConfigEntry<string> keyEntry15 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_6", "f6", (ConfigDescription)null);
			ConfigEntry<string> keyEntry16 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_7", "f7", (ConfigDescription)null);
			ConfigEntry<string> keyEntry17 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_8", "f8", (ConfigDescription)null);
			ConfigEntry<string> keyEntry18 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_9", "f9", (ConfigDescription)null);
			ConfigEntry<string> keyEntry19 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_10", "f10", (ConfigDescription)null);
			ConfigEntry<string> keyEntry20 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_11", "f11", (ConfigDescription)null);
			ConfigEntry<string> keyEntry21 = config.Bind<string>("Keybinds.GhostMode", "control_enemy_12", "f12", (ConfigDescription)null);
			InputKeys.GHOST_SPAWN_ENEMY_1 = GetKeyControlFromConfig(keyEntry10, InputKeys.GHOST_SPAWN_ENEMY_1);
			InputKeys.GHOST_SPAWN_ENEMY_2 = GetKeyControlFromConfig(keyEntry11, InputKeys.GHOST_SPAWN_ENEMY_2);
			InputKeys.GHOST_SPAWN_ENEMY_3 = GetKeyControlFromConfig(keyEntry12, InputKeys.GHOST_SPAWN_ENEMY_3);
			InputKeys.GHOST_SPAWN_ENEMY_4 = GetKeyControlFromConfig(keyEntry13, InputKeys.GHOST_SPAWN_ENEMY_4);
			InputKeys.GHOST_SPAWN_ENEMY_5 = GetKeyControlFromConfig(keyEntry14, InputKeys.GHOST_SPAWN_ENEMY_5);
			InputKeys.GHOST_SPAWN_ENEMY_6 = GetKeyControlFromConfig(keyEntry15, InputKeys.GHOST_SPAWN_ENEMY_6);
			InputKeys.GHOST_SPAWN_ENEMY_7 = GetKeyControlFromConfig(keyEntry16, InputKeys.GHOST_SPAWN_ENEMY_7);
			InputKeys.GHOST_SPAWN_ENEMY_8 = GetKeyControlFromConfig(keyEntry17, InputKeys.GHOST_SPAWN_ENEMY_8);
			InputKeys.GHOST_SPAWN_ENEMY_9 = GetKeyControlFromConfig(keyEntry18, InputKeys.GHOST_SPAWN_ENEMY_9);
			InputKeys.GHOST_SPAWN_ENEMY_10 = GetKeyControlFromConfig(keyEntry19, InputKeys.GHOST_SPAWN_ENEMY_10);
			InputKeys.GHOST_SPAWN_ENEMY_11 = GetKeyControlFromConfig(keyEntry20, InputKeys.GHOST_SPAWN_ENEMY_11);
			InputKeys.GHOST_SPAWN_ENEMY_12 = GetKeyControlFromConfig(keyEntry21, InputKeys.GHOST_SPAWN_ENEMY_12);
			InputKeys.GHOST_SPAWN_ENEMY_KEYS = new List<KeyControl>
			{
				InputKeys.GHOST_SPAWN_ENEMY_1,
				InputKeys.GHOST_SPAWN_ENEMY_2,
				InputKeys.GHOST_SPAWN_ENEMY_3,
				InputKeys.GHOST_SPAWN_ENEMY_4,
				InputKeys.GHOST_SPAWN_ENEMY_5,
				InputKeys.GHOST_SPAWN_ENEMY_6,
				InputKeys.GHOST_SPAWN_ENEMY_7,
				InputKeys.GHOST_SPAWN_ENEMY_8,
				InputKeys.GHOST_SPAWN_ENEMY_9,
				InputKeys.GHOST_SPAWN_ENEMY_10,
				InputKeys.GHOST_SPAWN_ENEMY_11,
				InputKeys.GHOST_SPAWN_ENEMY_12
			};
			ConfigEntry<string> keyEntry22 = config.Bind<string>("Keybinds.MonsterMode", "toggle_ai_key", "f1", (ConfigDescription)null);
			InputKeys.ENEMY_TOGGLE_AI_KEY = GetKeyControlFromConfig(keyEntry22, InputKeys.ENEMY_TOGGLE_AI_KEY);
		}

		private KeyControl GetKeyControlFromConfig(ConfigEntry<string> keyEntry, KeyControl defaultKey)
		{
			try
			{
				KeyControl val = Keyboard.current.FindKeyOnCurrentKeyboardLayout(keyEntry.Value);
				if (val != null)
				{
					return val;
				}
				return defaultKey;
			}
			catch (Exception ex)
			{
				ControlCompanyPlugin.Instance.logger.LogError((object)("Cannot rebind key for " + ((ConfigEntryBase)keyEntry).Definition.Key + " to " + keyEntry.Value + ": " + ex.Message));
				return defaultKey;
			}
		}
	}
	public class EnemyAttributes
	{
		public float WalkSpeed { get; set; } = 5f;


		public float RunSpeed { get; set; } = 7f;


		public bool PlayerControlsRotation { get; set; } = true;


		public float CamHeight { get; set; } = 2f;


		public float CamDistance { get; set; } = -3.5f;


		public string EnemyName { get; set; } = "";

	}
	internal static class EnemyConfiguration
	{
		public static HashSet<Type> ALLOWLISTED_ENEMIES = new HashSet<Type>
		{
			typeof(BlobAI),
			typeof(NutcrackerEnemyAI),
			typeof(HoarderBugAI),
			typeof(CrawlerAI),
			typeof(PufferAI),
			typeof(CentipedeAI),
			typeof(JesterAI),
			typeof(ForestGiantAI),
			typeof(BaboonBirdAI),
			typeof(FlowermanAI)
		};

		public static HashSet<Type> EXPERIMENTAL_ENEMIES = new HashSet<Type> { typeof(MouthDogAI) };

		public const float DEFAULT_WALK_SPEED = 5f;

		public const float DEFAULT_RUN_SPEED = 7f;

		public const float DEFAULT_CAM_DISTANCE = -3.5f;

		public const float DEFAULT_CAM_HEIGHT = 2f;

		public const bool DEFAULT_PLAYER_CONTROLS_ROTATION = true;

		public static Dictionary<Type, EnemyAttributes> ENEMY_ATTRIBUTES = new Dictionary<Type, EnemyAttributes>
		{
			{
				typeof(BlobAI),
				new EnemyAttributes
				{
					WalkSpeed = 2f,
					RunSpeed = 2f,
					PlayerControlsRotation = false,
					EnemyName = "Blob"
				}
			},
			{
				typeof(CrawlerAI),
				new EnemyAttributes
				{
					WalkSpeed = 6f,
					RunSpeed = 12f,
					EnemyName = "Thumper"
				}
			},
			{
				typeof(JesterAI),
				new EnemyAttributes
				{
					WalkSpeed = 4f,
					RunSpeed = 6f,
					EnemyName = "Jester"
				}
			},
			{
				typeof(ForestGiantAI),
				new EnemyAttributes
				{
					WalkSpeed = 5f,
					RunSpeed = 7f,
					CamDistance = -7f,
					CamHeight = 10f,
					EnemyName = "Forest Keeper"
				}
			},
			{
				typeof(MouthDogAI),
				new EnemyAttributes
				{
					WalkSpeed = 4f,
					RunSpeed = 8f,
					CamDistance = -5f,
					CamHeight = 5f,
					EnemyName = "Eyeless Dog"
				}
			},
			{
				typeof(FlowermanAI),
				new EnemyAttributes
				{
					EnemyName = "Bracken",
					RunSpeed = 8f
				}
			},
			{
				typeof(PufferAI),
				new EnemyAttributes
				{
					EnemyName = "Spore Lizard"
				}
			},
			{
				typeof(HoarderBugAI),
				new EnemyAttributes
				{
					EnemyName = "Hoarding Bug"
				}
			},
			{
				typeof(CentipedeAI),
				new EnemyAttributes
				{
					EnemyName = "Snare Flea",
					CamHeight = 1.5f,
					CamDistance = -3f
				}
			},
			{
				typeof(SpringManAI),
				new EnemyAttributes
				{
					EnemyName = "Coil-Head"
				}
			},
			{
				typeof(SandSpiderAI),
				new EnemyAttributes
				{
					EnemyName = "Bunker Spider"
				}
			},
			{
				typeof(DressGirlAI),
				new EnemyAttributes
				{
					EnemyName = "Ghost Girl"
				}
			},
			{
				typeof(MaskedPlayerEnemy),
				new EnemyAttributes
				{
					EnemyName = "Masked"
				}
			}
		};

		private static readonly EnemyAttributes DEFAULT_ATTRIBUTES = new EnemyAttributes();

		public static Dictionary<Type, Func<GameObject, EnemyController>> ENEMY_CONTROLLERS = new Dictionary<Type, Func<GameObject, EnemyController>>
		{
			{
				typeof(NutcrackerEnemyAI),
				(GameObject controller) => controller.AddComponent<NutcrackerEnemyController>()
			},
			{
				typeof(CentipedeAI),
				(GameObject controller) => controller.AddComponent<CentipedeEnemyController>()
			},
			{
				typeof(PufferAI),
				(GameObject controller) => controller.AddComponent<PufferEnemyController>()
			},
			{
				typeof(JesterAI),
				(GameObject controller) => controller.AddComponent<JesterEnemyController>()
			},
			{
				typeof(ForestGiantAI),
				(GameObject controller) => controller.AddComponent<ForestGiantEnemyController>()
			},
			{
				typeof(MouthDogAI),
				(GameObject controller) => controller.AddComponent<MouthDogEnemyController>()
			},
			{
				typeof(HoarderBugAI),
				(GameObject controller) => controller.AddComponent<HoardingBugEnemyController>()
			},
			{
				typeof(FlowermanAI),
				(GameObject controller) => controller.AddComponent<FlowermanEnemyController>()
			}
		};

		public static EnemyAttributes GetEnemyAttributes(this EnemyAI enemyAI)
		{
			return ExtensionMethods.GetValueOrDefault(ENEMY_ATTRIBUTES, ((object)enemyAI).GetType(), DEFAULT_ATTRIBUTES);
		}

		public static bool IsEnemyAllowlisted(this EnemyAI enemyAI)
		{
			return ALLOWLISTED_ENEMIES.Contains(((object)enemyAI).GetType());
		}

		public static bool IsEnemyExperimental(this EnemyAI enemyAI)
		{
			return EXPERIMENTAL_ENEMIES.Contains(((object)enemyAI).GetType());
		}

		public static string GetEnemyName(this EnemyAI enemyAI)
		{
			EnemyAttributes valueOrDefault = ExtensionMethods.GetValueOrDefault(ENEMY_ATTRIBUTES, ((object)enemyAI).GetType(), null);
			if (valueOrDefault == null)
			{
				return enemyAI.enemyType.enemyName;
			}
			return valueOrDefault.EnemyName;
		}

		public static EnemyController GetAndAttachEnemyController(this EnemyAI enemyAI, GameObject controller)
		{
			return ExtensionMethods.GetValueOrDefault(ENEMY_CONTROLLERS, ((object)enemyAI).GetType(), (GameObject c) => c.AddComponent<EnemyController>())(controller);
		}
	}
}