using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LCMoniterEnemies.Patches;
using Microsoft.CodeAnalysis;
using OpenBodyCams;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("NoteBoxz.MonitorEnemies")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.5.0.0")]
[assembly: AssemblyInformationalVersion("1.5.0+bf869a25a81b73caebcd5c45ef1dd44933c6e202")]
[assembly: AssemblyProduct("LCMoniterEnemies")]
[assembly: AssemblyTitle("NoteBoxz.MonitorEnemies")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.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.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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LCMoniterEnemies
{
	public class EnemyPos : MonoBehaviour
	{
		public EnemyAI Root = null;

		public TransformAndName TnN = null;

		public Transform? BodyCamPoint = null;

		public static Dictionary<EnemyType, Transform> BodyCamPoints = new Dictionary<EnemyType, Transform>();

		public void OnDestroy()
		{
			ManualCameraRendererPatch.RemoveEnemyFromRadarTargets(this);
		}

		public void LateUpdate()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localPosition = new Vector3(LCMoniterEnemies.TargetXoffset.Value, LCMoniterEnemies.TargetYoffset.Value, LCMoniterEnemies.TargetZoffset.Value);
		}

		public void Update()
		{
			if (Root.isEnemyDead && LCMoniterEnemies.AutoSwitchOnEnemyDeath.Value)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void Start()
		{
			if (LCMoniterEnemies.CreateBodyCam.Value)
			{
				if (BodyCamPoints.ContainsKey(Root.enemyType))
				{
					BodyCamPoint = BodyCamPoints[Root.enemyType];
				}
				else if ((Object)(object)((Component)this).transform.parent != (Object)null)
				{
					BodyCamPoint = GetOrCreateBodyCamPoint(((Component)((Component)this).transform.parent).gameObject);
				}
			}
		}

		public static Transform? GetOrCreateBodyCamPoint(GameObject obj)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			Transform[] componentsInChildren = obj.GetComponentsInChildren<Transform>(false);
			NavMeshAgent componentInChildren = obj.GetComponentInChildren<NavMeshAgent>();
			Transform[] array = componentsInChildren;
			foreach (Transform val in array)
			{
				if (!((Component)val).gameObject.activeSelf)
				{
					continue;
				}
				string text = ((Object)((Component)val).gameObject).name.ToLower();
				if (text.Contains("head") || text.Contains("h_j000") || text.Contains("f_j001"))
				{
					GameObject val2 = new GameObject("BodyCamPoint");
					val2.transform.SetParent(val);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						val2.transform.rotation = Quaternion.LookRotation(((Component)componentInChildren).transform.forward);
						Vector3 localPosition = ((Component)componentInChildren).transform.forward * componentInChildren.radius * 0.1f;
						localPosition.y = ((Component)val).transform.localPosition.y;
						val2.transform.localPosition = localPosition;
					}
					ManualLogSource logger = LCMoniterEnemies.Logger;
					string name = ((Object)obj).name;
					object arg = val2.transform.localPosition;
					Quaternion localRotation = val2.transform.localRotation;
					logger.LogDebug((object)$"Created BodyCamPoint for {name} at {arg}, {((Quaternion)(ref localRotation)).eulerAngles}");
					return val2.transform;
				}
			}
			return null;
		}
	}
	[BepInPlugin("NoteBoxz.MonitorEnemies", "LCMoniterEnemies", "1.5.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class LCMoniterEnemies : BaseUnityPlugin
	{
		public static List<EnemyType> EnemyTypes = (from e in Resources.FindObjectsOfTypeAll<EnemyType>()
			where (Object)(object)e.enemyPrefab != (Object)null
			group e by e.enemyPrefab into g
			select g.First()).ToList();

		public static LCMoniterEnemies Instance { get; private set; } = null;


		internal static ManualLogSource Logger { get; private set; } = null;


		internal static Harmony? Harmony { get; set; }

		internal static ConfigEntry<string> BlackList { get; set; } = null;


		internal static ConfigEntry<float> TargetYoffset { get; set; } = null;


		internal static ConfigEntry<float> TargetXoffset { get; set; } = null;


		internal static ConfigEntry<float> TargetZoffset { get; set; } = null;


		internal static ConfigEntry<bool> AutoSwitchOnEnemyDeath { get; set; } = null;


		internal static ConfigEntry<bool> CreateBodyCam { get; set; } = null;


		internal static ConfigEntry<bool> TryTelewarp { get; set; } = null;


		public static List<string> GetParsedAttackBlacklist()
		{
			if (string.IsNullOrEmpty(BlackList.Value))
			{
				return new List<string>();
			}
			return BlackList.Value.Split(',').ToList();
		}

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			Patch();
			BlackList = ((BaseUnityPlugin)this).Config.Bind<string>("Settings", "Enemy Blacklist", "", "The list of enemy names that wont be monitored (separated by commas, no spaces in between) (item1,item2,item3...)");
			TargetYoffset = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Camera Target Y Offset", 0f, "The Y (Vertical) Offset of the Enemy's target.");
			TargetXoffset = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Camera Target X Offset", 0f, "The X (Horizontal) Offset of the Enemy's target.");
			TargetZoffset = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Camera Target Z Offset", 0f, "The Z (Depth) Offset of the Enemy's target.");
			AutoSwitchOnEnemyDeath = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Auto Switch on Enemy Death", false, "Automatically switch to the next enemy when the current one dies.");
			CreateBodyCam = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Create BodyCam", true, "Create a BodyCam for each enemy. If false, the enemy will spesfic point for a bodycam.");
			TryTelewarp = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Allow Telepor", true, "Try to teleport enemies to the ship when they are targeted by the teleporter. (Could break some enemies AI)");
			Logger.LogInfo((object)"NoteBoxz.MonitorEnemies v1.5.0 has loaded!");
		}

		internal static void Patch()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("NoteBoxz.MonitorEnemies");
			}
			Logger.LogDebug((object)"Patching...");
			try
			{
				Type[] typesWithErrorHandling = GetTypesWithErrorHandling();
				Type[] array = typesWithErrorHandling;
				foreach (Type type in array)
				{
					try
					{
						Harmony.PatchAll(type);
					}
					catch (Exception ex)
					{
						Logger.LogError((object)("Error patching type " + type.FullName + ": " + ex.Message));
						if (ex.InnerException != null)
						{
							Logger.LogError((object)("Inner exception: " + ex.InnerException.Message));
						}
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.LogError((object)("Error during patching process: " + ex2.Message));
				if (ex2.InnerException != null)
				{
					Logger.LogError((object)("Inner exception: " + ex2.InnerException.Message));
				}
			}
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static Type[] GetTypesWithErrorHandling()
		{
			try
			{
				return Assembly.GetExecutingAssembly().GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				Logger.LogWarning((object)"ReflectionTypeLoadException caught while getting types. Some types will be skipped.");
				Exception[] loaderExceptions = ex.LoaderExceptions;
				foreach (Exception ex2 in loaderExceptions)
				{
					Logger.LogWarning((object)("Loader Exception: " + ex2.Message));
					if (ex2 is FileNotFoundException ex3)
					{
						Logger.LogWarning((object)("Could not load file: " + ex3.FileName));
					}
				}
				return ex.Types.Where((Type t) => t != null).ToArray();
			}
			catch (Exception ex4)
			{
				Logger.LogError((object)("Unexpected error while getting types: " + ex4.Message));
				return new Type[0];
			}
		}

		internal static void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"MoniterEnemies unpatched!  Harmony unloaded.");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "NoteBoxz.MonitorEnemies";

		public const string PLUGIN_NAME = "LCMoniterEnemies";

		public const string PLUGIN_VERSION = "1.5.0";
	}
}
namespace LCMoniterEnemies.Patches
{
	[HarmonyPatch(typeof(BodyCamComponent))]
	internal class BodyCamComponetPatch
	{
		[HarmonyPatch("SetTargetToTransform")]
		[HarmonyPrefix]
		public static bool SetTargetToTransformPrefix(ref Transform transform)
		{
			EnemyPos enemyPos = default(EnemyPos);
			if ((Object)(object)transform != (Object)null && ((Component)transform).gameObject.TryGetComponent<EnemyPos>(ref enemyPos) && (Object)(object)enemyPos.BodyCamPoint != (Object)null)
			{
				transform = enemyPos.BodyCamPoint;
				LCMoniterEnemies.Logger.LogDebug((object)("BodyCamComponent.SetTargetToTransform: Setting target to " + ((Object)enemyPos.BodyCamPoint).name + " for enemy " + ((Object)((Component)enemyPos.Root).gameObject).name));
			}
			else
			{
				LCMoniterEnemies.Logger.LogDebug((object)"BodyCamComponent.SetTargetToTransform: No valid EnemyPos or BodyCamPoint found, using original transform.");
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EnemyAI))]
	internal class EnemyAIPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void StarPostFix(EnemyAI __instance)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			EnemyAI __instance2 = __instance;
			if (!LCMoniterEnemies.GetParsedAttackBlacklist().Contains(__instance2.enemyType.enemyName) && (Object)(object)((Component)__instance2).GetComponentInChildren<EnemyPos>() == (Object)null)
			{
				int num = Object.FindObjectOfType<ManualCameraRenderer>().radarTargets.Count((TransformAndName target) => target.name.StartsWith(__instance2.enemyType.enemyName));
				string text = "???";
				text = ((num <= 0) ? (__instance2.enemyType.enemyName ?? "") : $"{__instance2.enemyType.enemyName} #{num}");
				GameObject val = new GameObject(text);
				Transform transform = ((Component)__instance2).transform;
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(0f, LCMoniterEnemies.TargetYoffset.Value, 0f);
				val.transform.position = transform.position + val2;
				val.transform.rotation = transform.rotation;
				val.transform.SetParent(transform, true);
				EnemyPos enemyPos = val.AddComponent<EnemyPos>();
				enemyPos.Root = __instance2;
				TransformAndName tnN = new TransformAndName(((Component)enemyPos).transform, text, true);
				enemyPos.TnN = tnN;
				ManualCameraRendererPatch.AddEnemyToRadarTargets(enemyPos);
			}
		}
	}
	[HarmonyPatch(typeof(ManualCameraRenderer))]
	internal class ManualCameraRendererPatch
	{
		public static EnemyAI? EnemyTargeting;

		[HarmonyPatch("updateMapTarget")]
		[HarmonyPostfix]
		public static void updateMapTargetPostfix(ManualCameraRenderer __instance, int setRadarTargetIndex, bool calledFromRPC = true)
		{
			EnemyPos component = ((Component)__instance.radarTargets[setRadarTargetIndex].transform).gameObject.GetComponent<EnemyPos>();
			if ((Object)(object)component != (Object)null)
			{
				EnemyTargeting = component.Root;
			}
		}

		public static void RemoveEnemyFromRadarTargets(EnemyPos enemyTransform)
		{
			if (enemyTransform.TnN == null)
			{
				LCMoniterEnemies.Logger.LogWarning((object)"EnemyPos's tranform and name was null when removing");
				return;
			}
			ManualCameraRenderer[] array = Object.FindObjectsOfType<ManualCameraRenderer>();
			ManualCameraRenderer[] array2 = array;
			foreach (ManualCameraRenderer val in array2)
			{
				if (val.targetTransformIndex + 1 < val.radarTargets.Count && val.radarTargets.Contains(enemyTransform.TnN) && LCMoniterEnemies.AutoSwitchOnEnemyDeath.Value && val.targetTransformIndex == val.radarTargets.IndexOf(enemyTransform.TnN) && ((NetworkBehaviour)val).IsServer)
				{
					val.SwitchRadarTargetAndSync(val.targetTransformIndex + 1);
				}
				if (val.targetTransformIndex + 1 >= val.radarTargets.Count && ((NetworkBehaviour)val).IsServer)
				{
					LCMoniterEnemies.Logger.LogWarning((object)$"{((Object)val).name} Predicted CameraViewIndex will be out of bounds when clearing, setting to {val.radarTargets.Count - 1}");
					val.SwitchRadarTargetAndSync(val.radarTargets.Count - 1);
				}
				if (val.radarTargets.Contains(enemyTransform.TnN))
				{
					val.radarTargets.Remove(enemyTransform.TnN);
				}
			}
		}

		public static void AddEnemyToRadarTargets(EnemyPos enemyTransform)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			if (enemyTransform.TnN == null)
			{
				LCMoniterEnemies.Logger.LogWarning((object)"EnemyPos's tranform and name was null when adding");
				return;
			}
			ManualCameraRenderer[] array = Object.FindObjectsOfType<ManualCameraRenderer>();
			ManualCameraRenderer[] array2 = array;
			foreach (ManualCameraRenderer val in array2)
			{
				if (enemyTransform.TnN == null)
				{
					LCMoniterEnemies.Logger.LogWarning((object)"EnemyPos's tranform and name was null when adding. Generateing new one...");
					TransformAndName tnN = new TransformAndName(((Component)enemyTransform).transform, ((Object)enemyTransform).name, true);
					enemyTransform.TnN = tnN;
				}
				if (!val.radarTargets.Contains(enemyTransform.TnN))
				{
					val.radarTargets.Add(enemyTransform.TnN);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ShipTeleporter))]
	internal class ShipTeleporterPatch
	{
		[CompilerGenerated]
		private sealed class <beamUpEnemy>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ShipTeleporter __instance;

			private EnemyAI <enemyToBeamUp>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <beamUpEnemy>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<enemyToBeamUp>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Expected O, but got Unknown
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enemyToBeamUp>5__1 = ManualCameraRendererPatch.EnemyTargeting;
					if ((Object)(object)<enemyToBeamUp>5__1 == (Object)null)
					{
						LCMoniterEnemies.Logger.LogInfo((object)"Targeted enemy is null");
						return false;
					}
					LCMoniterEnemies.Logger.LogInfo((object)("Attemping to teleport enemy '" + ((Object)((Component)<enemyToBeamUp>5__1).gameObject).name + "'"));
					if (StartOfRound.Instance.shipIsLeaving)
					{
						LCMoniterEnemies.Logger.LogInfo((object)("Ship could not teleport enemy '" + ((Object)((Component)<enemyToBeamUp>5__1).gameObject).name + "' because the ship is leaving the nav mesh."));
						return false;
					}
					<enemyToBeamUp>5__1.ShipTeleportEnemy();
					<enemyToBeamUp>5__1.creatureSFX.PlayOneShot(__instance.beamUpPlayerBodySFX);
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (StartOfRound.Instance.shipIsLeaving)
					{
						LCMoniterEnemies.Logger.LogInfo((object)("Ship could not teleport enemy '" + ((Object)((Component)<enemyToBeamUp>5__1).gameObject).name + "' because the ship is leaving the nav mesh."));
						return false;
					}
					<enemyToBeamUp>5__1.SetEnemyOutside(true);
					if (((NetworkBehaviour)<enemyToBeamUp>5__1).IsOwner)
					{
						((Behaviour)<enemyToBeamUp>5__1.agent).enabled = false;
						((Component)<enemyToBeamUp>5__1).transform.position = __instance.teleporterPosition.position;
						((Behaviour)<enemyToBeamUp>5__1.agent).enabled = true;
					}
					<enemyToBeamUp>5__1.serverPosition = __instance.teleporterPosition.position;
					__instance.shipTeleporterAudio.PlayOneShot(__instance.teleporterBeamUpSFX);
					if (GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom)
					{
						HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPatch("beamUpPlayer")]
		[HarmonyPrefix]
		public static void beamUpPlayerPostfix(ShipTeleporter __instance)
		{
			if (!LCMoniterEnemies.TryTelewarp.Value)
			{
				LCMoniterEnemies.Logger.LogInfo((object)"Telewarp is disabled, skipping beam up.");
			}
			else
			{
				((MonoBehaviour)__instance).StartCoroutine(beamUpEnemy(__instance));
			}
		}

		[IteratorStateMachine(typeof(<beamUpEnemy>d__1))]
		private static IEnumerator beamUpEnemy(ShipTeleporter __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <beamUpEnemy>d__1(0)
			{
				__instance = __instance
			};
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static void StartPrefix()
		{
			//IL_00b8: 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)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if (!LCMoniterEnemies.CreateBodyCam.Value)
			{
				return;
			}
			foreach (EnemyType enemyType in LCMoniterEnemies.EnemyTypes)
			{
				try
				{
					if ((Object)(object)enemyType == (Object)null || (Object)(object)enemyType.enemyPrefab == (Object)null)
					{
						LCMoniterEnemies.Logger.LogWarning((object)"EnemyType or its prefab is null, skipping...");
						continue;
					}
					Transform orCreateBodyCamPoint = EnemyPos.GetOrCreateBodyCamPoint(enemyType.enemyPrefab.gameObject);
					if ((Object)(object)orCreateBodyCamPoint != (Object)null)
					{
						EnemyPos.BodyCamPoints[enemyType] = orCreateBodyCamPoint;
						LCMoniterEnemies.Logger.LogDebug((object)$"BodyCamPoint for {((Object)enemyType).name} set to {((Object)orCreateBodyCamPoint).name} at {orCreateBodyCamPoint.position},{orCreateBodyCamPoint.rotation} ({orCreateBodyCamPoint.localPosition})");
					}
				}
				catch (Exception ex)
				{
					LCMoniterEnemies.Logger.LogError((object)("Error while processing EnemyType: " + ex.Message));
				}
			}
		}
	}
}