Decompiled source of EOSExt LevelSpawnedSentry v1.1.3

plugins/Inas07.EOSExt.LevelSpawnedSentry.dll

Decompiled 2 weeks ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AIGraph;
using AK;
using Agents;
using BepInEx;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using EOSExt.LevelSpawnedSentry.Definition;
using EOSExt.LevelSpawnedSentry.Impl;
using EOSExt.LevelSpawnedSentry.PlayerGUIMessage;
using ExtraObjectiveSetup;
using ExtraObjectiveSetup.BaseClasses;
using ExtraObjectiveSetup.ExtendedWardenEvents;
using ExtraObjectiveSetup.Utils;
using FX_EffectSystem;
using FloLib.Infos;
using FloLib.Networks.Replications;
using GTFO.API;
using GameData;
using GameEvent;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSystem;
using LevelGeneration;
using Localization;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using TenChambers.EventHandlers;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Inas07.EOSExt.LevelSpawnedSentry")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+68b383eb50863993e1dba11bdd637c0fa0347729")]
[assembly: AssemblyProduct("Inas07.EOSExt.LevelSpawnedSentry")]
[assembly: AssemblyTitle("Inas07.EOSExt.LevelSpawnedSentry")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EOSExt.LevelSpawnedSentry
{
	public class LevelSpawnedSentryManager : GenericExpeditionDefinitionManager<LevelSpawnedSentryDefinition>
	{
		public enum LSS_WardenEvents
		{
			ChangeLSSState = 910
		}

		public static LevelSpawnedSentryManager Current { get; private set; }

		protected override string DEFINITION_NAME => "LevelSpawnedSentry";

		private Dictionary<string, LSS> LSSDict { get; } = new Dictionary<string, LSS>();


		internal List<LSS> LSSInstances { get; } = new List<LSS>();


		private void PrepareForBuild()
		{
			Clear();
			if (!base.definitions.TryGetValue(base.CurrentMainLevelLayout, out var value))
			{
				return;
			}
			for (int i = 0; i < value.Definitions.Count; i++)
			{
				LevelSpawnedSentryDefinition levelSpawnedSentryDefinition = value.Definitions[i];
				LSS lSS = LSS.Instantiate(levelSpawnedSentryDefinition, i);
				LSSInstances.Add(lSS);
				if (LSSDict.ContainsKey(levelSpawnedSentryDefinition.WorldEventObjectFilter))
				{
					EOSLogger.Warning("LevelSpawnSentry: found duplicate WorldEventObjectFilter '" + levelSpawnedSentryDefinition.WorldEventObjectFilter + "'");
				}
				LSSDict[levelSpawnedSentryDefinition.WorldEventObjectFilter] = lSS;
			}
		}

		private void Clear()
		{
			LSSInstances.ForEach(delegate(LSS i)
			{
				i.Destroy();
			});
			LSSInstances.Clear();
			LSSDict.Clear();
		}

		private LevelSpawnedSentryManager()
		{
			LevelAPI.OnBuildStart += PrepareForBuild;
			LevelAPI.OnLevelCleanup += Clear;
		}

		static LevelSpawnedSentryManager()
		{
			Current = new LevelSpawnedSentryManager();
			EOSWardenEventManager.Current.AddEventDefinition(LSS_WardenEvents.ChangeLSSState.ToString(), 910u, (Action<WardenObjectiveEventData>)ChangeLSSState);
		}

		private static void ChangeLSSState(WardenObjectiveEventData e)
		{
			if (!Current.LSSDict.TryGetValue(e.WorldEventObjectFilter, out var value))
			{
				EOSLogger.Error("ChangeLSSState: Cannot find LSS with name '" + e.WorldEventObjectFilter + "'");
			}
			else if (SNet.IsMaster)
			{
				bool targetEnemy = e.EnemyID == 0;
				bool targetPlayer = e.SustainedEventSlotIndex > 0;
				bool markerVisible = e.Count == 0;
				bool canRefill = e.FogSetting == 0;
				LSSSyncState lSSSyncState = new LSSSyncState(value.State);
				lSSSyncState.Enabled = e.Enabled;
				lSSSyncState.TargetEnemy = targetEnemy;
				lSSSyncState.TargetPlayer = targetPlayer;
				lSSSyncState.MarkerVisible = markerVisible;
				lSSSyncState.CanRefill = canRefill;
				lSSSyncState.Ammo = value.LSSComp.Sentry.Ammo;
				LSSSyncState state = lSSSyncState;
				value.StateReplicator.SetState(state);
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Inas.EOSExt.LevelSpawnedSentry", "EOSExt.LevelSpawnedSentry", "1.1.3")]
	public class EntryPoint : BasePlugin
	{
		public const string AUTHOR = "Inas";

		public const string PLUGIN_NAME = "EOSExt.LevelSpawnedSentry";

		public const string VERSION = "1.1.3";

		private Harmony m_Harmony;

		public override void Load()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			SetupManagers();
			m_Harmony = new Harmony("EOSExt.LevelSpawnedSentry");
			m_Harmony.PatchAll();
			EOSLogger.Log("ExtraObjectiveSetup.LevelSpawnedSentry loaded.");
		}

		private void SetupManagers()
		{
			((GenericExpeditionDefinitionManager<LevelSpawnedSentryDefinition>)LevelSpawnedSentryManager.Current).Init();
		}
	}
	public class LSS
	{
		[CompilerGenerated]
		private sealed class <s_sync>d__35 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private int <i>5__2;

			private WaitForSeconds <waitOutOfLevel>5__3;

			private WaitForSeconds <waitInLevel>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<waitOutOfLevel>5__3 = null;
				<waitInLevel>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Invalid comparison between Unknown and I4
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f9: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					<waitOutOfLevel>5__3 = new WaitForSeconds(15f);
					<waitInLevel>5__4 = null;
					break;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if ((int)GameStateManager.CurrentStateName == 10)
				{
					if (SNet.IsMaster && LevelSpawnedSentryManager.Current.LSSInstances.Count > 0)
					{
						if (0 <= <i>5__2 && <i>5__2 < LevelSpawnedSentryManager.Current.LSSInstances.Count)
						{
							LSS lSS = LevelSpawnedSentryManager.Current.LSSInstances[<i>5__2];
							if ((Object)(object)lSS.LSSComp == (Object)null)
							{
								EOSLogger.Error("LSSSync: found LSS without LSSComp: " + lSS.Def.WorldEventObjectFilter);
							}
							else
							{
								SentryGunInstance sentry = lSS.LSSComp.Sentry;
								if ((Object)(object)sentry != (Object)null)
								{
									LSSSyncState state = lSS.StateReplicator.State;
									if ((double)Math.Abs(sentry.Ammo - state.Ammo) > 0.0001)
									{
										LSSSyncState state2 = new LSSSyncState(state)
										{
											Ammo = sentry.Ammo
										};
										lSS.StateReplicator.SetState(state2);
									}
								}
							}
						}
						if (<i>5__2 == LevelSpawnedSentryManager.Current.LSSInstances.Count - 1)
						{
							EOSLogger.Debug($"LSS: master synced {LevelSpawnedSentryManager.Current.LSSInstances.Count} in {15f} seconds");
						}
						<i>5__2 = (<i>5__2 + 1) % LevelSpawnedSentryManager.Current.LSSInstances.Count;
					}
					if (<waitInLevel>5__4 == null)
					{
						<waitInLevel>5__4 = new WaitForSeconds(15f / (float)Math.Max(1, LevelSpawnedSentryManager.Current.LSSInstances.Count));
					}
					<>2__current = <waitInLevel>5__4;
					<>1__state = 1;
					return true;
				}
				<waitInLevel>5__4 = null;
				<>2__current = <waitOutOfLevel>5__3;
				<>1__state = 2;
				return true;
			}

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

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

		public static readonly Color OffColor;

		public static readonly Color TargetBothColor;

		public static readonly Color TargetPlayerOnlyColor;

		public static readonly Color TargetEnemyOnlyColor;

		public static readonly Color DoesNotTargetColor;

		public const string PUBLIC_NAME_PREFIX = "E0$L$$";

		private const float SYNC_ALL_IN = 15f;

		private static Coroutine s_syncLSSAmmoCoroutine;

		private LSSTargeted m_LSSTargeted = new LSSTargeted();

		public const string LSS_SYNC_EVT = "LSS_SYNC_EVT";

		public LevelSpawnedSentryDefinition Def { get; }

		public int InstanceIndex { get; }

		public LSSSyncState State => StateReplicator?.State ?? default(LSSSyncState);

		internal StateReplicator<LSSSyncState> StateReplicator { get; private set; }

		public LSSComp LSSComp { get; private set; }

		public int LastSyncedTargetedPlayer => m_LSSTargeted.PlayerSlotIndex;

		public static Color GetScanningColor(bool targetEnemy, bool targetPlayer)
		{
			//IL_0000: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			//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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0023: 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)
			Color val = Color.grey * 0.5f;
			if (targetEnemy && targetPlayer)
			{
				return TargetBothColor;
			}
			if (targetEnemy && !targetPlayer)
			{
				return TargetEnemyOnlyColor;
			}
			if (!targetEnemy && targetPlayer)
			{
				return TargetPlayerOnlyColor;
			}
			return DoesNotTargetColor;
		}

		public static string GetMarkerText(bool targetEnemy, bool targetPlayer)
		{
			string empty = string.Empty;
			string empty2 = string.Empty;
			if (targetEnemy && targetPlayer)
			{
				empty = "LSS.State.Both";
				empty2 = "HAVOC";
			}
			else if (targetEnemy && !targetPlayer)
			{
				empty = "LSS.State.Normal";
				empty2 = "NORMAL";
			}
			else if (!targetEnemy && targetPlayer)
			{
				empty = "LSS.State.Player";
				empty2 = "HOSTILE";
			}
			else
			{
				empty = "LSS.State.Idle";
				empty2 = "IDLE";
			}
			TextDataBlock block = GameDataBlockBase<TextDataBlock>.GetBlock(empty);
			if (block == null)
			{
				return empty2;
			}
			return Text.Get(((GameDataBlockBase<TextDataBlock>)(object)block).persistentID);
		}

		internal void AssignInstance(LSSComp comp)
		{
			if (!comp.IsSetup)
			{
				EOSLogger.Error("LSS: Assigning to LSS '" + comp.Def.WorldEventObjectFilter + "' an un-setup LSSComp!");
				return;
			}
			bool num = (Object)(object)LSSComp != (Object)null;
			if (num)
			{
				EOSLogger.Warning("LSS: re-assigning LSSComp to '" + comp.Def.WorldEventObjectFilter + "'!");
			}
			LSSComp = comp;
			if (num)
			{
				OnStateChanged(State, State, isRecall: false);
			}
		}

		internal void SetupReplicator()
		{
			if (StateReplicator != null)
			{
				return;
			}
			LevelSpawnedSentryDefinition def = Def;
			uint num = EOSNetworking.AllotReplicatorID();
			if (num != 0)
			{
				LSSSyncState lSSSyncState = new LSSSyncState(def.InitialState);
				lSSSyncState.Ammo = def.InitialAmmo;
				LSSSyncState lSSSyncState2 = lSSSyncState;
				StateReplicator = StateReplicator<LSSSyncState>.Create(num, lSSSyncState2, (LifeTimeType)1, (IStateReplicatorHolder<LSSSyncState>)null);
				StateReplicator.OnStateChanged += OnStateChanged;
				if (SNet.IsMaster)
				{
					StateReplicator.SetState(lSSSyncState2);
				}
			}
		}

		private void OnStateChanged(LSSSyncState oldState, LSSSyncState newState, bool isRecall)
		{
			if (isRecall)
			{
				EOSLogger.Warning("LSS.OnStateChanged recall! Gonna re-assign LSSComp!");
				SpawnLSS_OnRecall();
			}
			else if ((Object)(object)LSSComp == (Object)null)
			{
				EOSLogger.Error("LSS.OnStateChanged: LSSComp is null!");
			}
			else
			{
				LSSComp.OnStateChanged(oldState, newState, isRecall);
			}
		}

		internal void Destroy()
		{
			EOSLogger.Error("LSS Destroyed: " + Def.WorldEventObjectFilter);
			LevelAPI.OnBuildDone -= SetupReplicator;
			LevelAPI.OnEnterLevel -= SpawnLSS_OnEnterLevel;
			StateReplicator?.Unload();
			StateReplicator = null;
		}

		private void SpawnLSS_OnEnterLevel()
		{
			SpawnLSS(Def.InitialAmmo);
		}

		private void SpawnLSS_OnRecall()
		{
			SpawnLSS(State.Ammo);
		}

		private void SpawnLSS(float ammo)
		{
			//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_001d: 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_0032: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			if (!SNet.IsMaster)
			{
				return;
			}
			LevelSpawnedSentryDefinition def = Def;
			Vector3 val = def.Position.ToVector3();
			AIG_GeomorphNodeVolume val2 = default(AIG_GeomorphNodeVolume);
			AIG_VoxelNodePillar val3 = default(AIG_VoxelNodePillar);
			AIG_INode val4 = default(AIG_INode);
			AIG_NodeCluster val5 = default(AIG_NodeCluster);
			if (!AIG_GeomorphNodeVolume.TryGetGeomorphVolume(0, def.DimensionIndex, val, ref val2) || !((AIG_NodeVolume)val2).m_voxelNodeVolume.TryGetPillar(val, ref val3) || !val3.TryGetVoxelNode(val.y, ref val4) || !AIG_NodeCluster.TryGetNodeCluster(val4.ClusterID, ref val5))
			{
				EOSLogger.Error("SpawnLSS: Position is not valid, try again inside an area.");
				return;
			}
			AIG_CourseNode courseNode = val5.CourseNode;
			PlayerOfflineGearDataBlock block = GameDataBlockBase<PlayerOfflineGearDataBlock>.GetBlock(def.PlayerOfflineGearDBId);
			if (block == null)
			{
				EOSLogger.Error($"SpawnLSS: missing PlayerOfflineGearDataBlock with Id {def.PlayerOfflineGearDBId}");
				return;
			}
			GearIDRange val6 = new GearIDRange(block.GearJSON);
			val6.PublicGearName = $"{"E0$L$$"}_{InstanceIndex}";
			val6.PlayfabItemId = ((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)block).name;
			val6.PlayfabItemInstanceId = $"OfflineGear_LSS_ID_{((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)block).persistentID}";
			val6.OfflineGearType = (eOfflineGearType)3;
			if (val6.GetCompID((eGearComponent)3) != 0)
			{
				GameDataBlockBase<ItemDataBlock>.GetBlock(val6.GetCompID((eGearComponent)3));
			}
			ItemReplicationManager.SpawnGear(val6, (delItemCallback)null, (ItemMode)3, val, def.Rotation.ToQuaternion(), courseNode, (PlayerAgent)null, ammo, Def.AmmoCap);
		}

		private LSS(LevelSpawnedSentryDefinition def, int instanceIndex)
		{
			Def = def;
			InstanceIndex = instanceIndex;
		}

		internal static LSS Instantiate(LevelSpawnedSentryDefinition def, int instanceIndex)
		{
			LSS lSS = new LSS(def, instanceIndex);
			LevelAPI.OnBuildDone += lSS.SetupReplicator;
			LevelAPI.OnEnterLevel += lSS.SpawnLSS_OnEnterLevel;
			return lSS;
		}

		[IteratorStateMachine(typeof(<s_sync>d__35))]
		private static IEnumerator s_sync()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <s_sync>d__35(0);
		}

		static LSS()
		{
			//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_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_0023: 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_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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			OffColor = ColorExt.Hex("#00000000");
			TargetBothColor = ColorExt.Hex("FFFA00");
			TargetPlayerOnlyColor = ColorExt.Hex("#F0192EFF");
			TargetEnemyOnlyColor = ColorExt.Hex("#00895CFF");
			DoesNotTargetColor = ColorExt.Hex("#198AF0FF") * 0.5f;
			s_syncLSSAmmoCoroutine = null;
			SetupSync();
			s_syncLSSAmmoCoroutine = CoroutineManager.StartPersistantCoroutine(CollectionExtensions.WrapToIl2Cpp(s_sync()));
			EOSLogger.Debug("===========================");
			EOSLogger.Debug("LSS Sync coroutine started");
			EOSLogger.Debug("===========================");
		}

		internal void OnTargetedPlayer(PlayerAgent player)
		{
			m_LSSTargeted.PlayerSlotIndex = ((player != null) ? player.Owner.PlayerSlotIndex() : (-1));
		}

		internal void OnUpdateMaster()
		{
			m_LSSTargeted.LSSInstanceIndex = InstanceIndex;
			NetworkAPI.InvokeEvent<LSSTargeted>("LSS_SYNC_EVT", m_LSSTargeted, (SNet_ChannelType)2);
		}

		private static void OnReceive(ulong sender, LSSTargeted data)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			int lSSInstanceIndex = data.LSSInstanceIndex;
			if (lSSInstanceIndex < 0 || lSSInstanceIndex >= LevelSpawnedSentryManager.Current.LSSInstances.Count)
			{
				EOSLogger.Error($"LSS_OnReceive: got packet with invalid instance index {lSSInstanceIndex}, LSSCount: {LevelSpawnedSentryManager.Current.LSSInstances.Count}, CurrentGameState: {GameStateManager.CurrentStateName}");
			}
			else
			{
				LevelSpawnedSentryManager.Current.LSSInstances[lSSInstanceIndex].m_LSSTargeted.PlayerSlotIndex = data.PlayerSlotIndex;
				EOSLogger.Warning($"LSSSync.OnReceive: LSS_{lSSInstanceIndex}, Player_{data.PlayerSlotIndex}");
			}
		}

		private static void SetupSync()
		{
			NetworkAPI.RegisterEvent<LSSTargeted>("LSS_SYNC_EVT", (Action<ulong, LSSTargeted>)OnReceive);
			EOSLogger.Debug("===========================");
			EOSLogger.Debug("LSSTargeted Sync EVT Registered");
			EOSLogger.Debug("===========================");
		}
	}
	[HarmonyPatch]
	public static class LSSDebug
	{
	}
}
namespace EOSExt.LevelSpawnedSentry.PlayerGUIMessage
{
	public class PlayerGUIMessageManager
	{
		private PUI_ObjectiveTimer m_timerLayer;

		private ISet<int> m_targetedByLSS = new HashSet<int>();

		public static PlayerGUIMessageManager Current { get; }

		public static PlayerGuiLayer PlayerGUILayer => GuiManager.PlayerLayer;

		internal void Setup(Transform root)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			m_timerLayer = ((Il2CppObjectBase)((GuiLayer)PlayerGUILayer).AddComp("Gui/Player/PUI_ObjectiveTimer", (GuiAnchor)0, new Vector2(0f, -200f), (Transform)null)).Cast<PUI_ObjectiveTimer>();
		}

		internal void OnLocalPlayerTargeted(LSS sentry)
		{
			m_targetedByLSS.Add(sentry.InstanceIndex);
			if (m_targetedByLSS.Count > 0 && !((Component)m_timerLayer).gameObject.active)
			{
				TextDataBlock block = GameDataBlockBase<TextDataBlock>.GetBlock("LSS.OnPlayerTargeted.GUIText");
				SetText((block != null) ? Text.Get(((GameDataBlockBase<TextDataBlock>)(object)block).persistentID) : "<color=red>OMG IM SO FKING DEAD</color>");
			}
		}

		internal void OnLocalPlayerUnTargeted(LSS sentry)
		{
			m_targetedByLSS.Remove(sentry.InstanceIndex);
			if (m_targetedByLSS.Count == 0)
			{
				Clear();
			}
		}

		public void SetText(string text)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			((Component)m_timerLayer).gameObject.active = true;
			m_timerLayer.UpdateTimerTitle(text);
			if ((int)GameStateManager.CurrentStateName == 10)
			{
				CoroutineManager.BlinkIn(((Component)m_timerLayer.m_titleText).gameObject, 0f);
			}
		}

		public void Clear()
		{
			((Component)m_timerLayer).gameObject.active = false;
			m_timerLayer.SetTimerTextEnabled(false);
		}

		private void OnLevelCleanup()
		{
			Clear();
			m_targetedByLSS.Clear();
		}

		private PlayerGUIMessageManager()
		{
			LevelAPI.OnBuildStart += OnLevelCleanup;
			LevelAPI.OnLevelCleanup += OnLevelCleanup;
		}

		static PlayerGUIMessageManager()
		{
			Current = new PlayerGUIMessageManager();
		}
	}
}
namespace EOSExt.LevelSpawnedSentry.Patches
{
	[HarmonyPatch]
	internal static class DisableAnalytic
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(AnalyticsManager), "SentryEventsPayload")]
		private static bool Pre_(SentryGunInstance __instance)
		{
			if ((Object)(object)__instance != (Object)null)
			{
				return (Object)(object)((Item)__instance).Owner != (Object)null;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SentryPlaced), "OnGameEvent")]
		private static bool Pre_(GameEventData data)
		{
			return (Object)(object)data.player != (Object)null;
		}
	}
	[HarmonyPatch]
	internal static class DisableWarp
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(SentryGunInstance), "OnWarp")]
		private static bool Pre_(SentryGunInstance __instance)
		{
			return (Object)(object)((Component)__instance).gameObject.GetComponent<LSSComp>() == (Object)null;
		}
	}
	[HarmonyPatch]
	internal static class Firing
	{
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(SentryGunInstance_Firing_Bullets), "FireBullet")]
		private static bool Pre_FireBullet(SentryGunInstance_Firing_Bullets __instance, bool doDamage, bool targetIsTagged)
		{
			//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)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: 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_01fb: Unknown result type (might be due to invalid IL or missing references)
			iSentrygunInstanceCore core = __instance.m_core;
			SentryGunInstance val = ((core != null) ? ((Il2CppObjectBase)core).TryCast<SentryGunInstance>() : null);
			LSSComp lSSComp = ((val != null) ? ((Component)val).gameObject.GetComponent<LSSComp>() : null);
			if ((Object)(object)lSSComp == (Object)null)
			{
				return true;
			}
			_ = lSSComp.LSS.State;
			WeaponHitData val3 = (SentryGunInstance_Firing_Bullets.s_weaponRayData = new WeaponHitData
			{
				randomSpread = __instance.m_archetypeData.HipFireSpread,
				fireDir = __instance.MuzzleAlign.forward
			});
			Vector3 val4 = default(Vector3);
			if (__instance.m_archetypeData.Sentry_FireTowardsTargetInsteadOfForward && __instance.m_core.TryGetTargetAimPos(ref val4))
			{
				WeaponHitData s_weaponRayData = SentryGunInstance_Firing_Bullets.s_weaponRayData;
				Vector3 val5 = val4 - __instance.MuzzleAlign.position;
				s_weaponRayData.fireDir = ((Vector3)(ref val5)).normalized;
			}
			if (Weapon.CastWeaponRay(__instance.MuzzleAlign, ref val3, LayerManager.MASK_SENTRYGUN_RAY))
			{
				SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = __instance.m_core.Owner;
				GameObject target = val.m_detection.Target;
				PlayerAgent val6 = ((target != null) ? target.GetComponent<PlayerAgent>() : null);
				if (val.m_detection.HasTarget && (Object)(object)val6 != (Object)null)
				{
					SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = val.m_detection.Target.GetComponent<PlayerAgent>();
				}
				else
				{
					SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = LocalPlayer.Agent;
				}
				SentryGunInstance_Firing_Bullets.s_weaponRayData.damage = (targetIsTagged ? (__instance.m_archetypeData.Damage * __instance.m_archetypeData.Sentry_DamageTagMulti) : __instance.m_archetypeData.Damage);
				SentryGunInstance_Firing_Bullets.s_weaponRayData.staggerMulti = __instance.m_archetypeData.GetSentryStaggerDamage(targetIsTagged);
				SentryGunInstance_Firing_Bullets.s_weaponRayData.precisionMulti = __instance.m_archetypeData.PrecisionDamageMulti;
				SentryGunInstance_Firing_Bullets.s_weaponRayData.damageFalloff = __instance.m_archetypeData.DamageFalloff;
				SentryGunInstance_Firing_Bullets.s_weaponRayData.vfxBulletHit = __instance.m_vfxBulletHit;
				BulletWeapon.BulletHit(SentryGunInstance_Firing_Bullets.s_weaponRayData, doDamage, 0f, 0u, true);
				RaycastHit rayHit = SentryGunInstance_Firing_Bullets.s_weaponRayData.rayHit;
				FX_Manager.EffectTargetPosition = ((RaycastHit)(ref rayHit)).point;
				Vector3 position = __instance.MuzzleAlign.position;
				rayHit = SentryGunInstance_Firing_Bullets.s_weaponRayData.rayHit;
				Debug.DrawLine(position, ((RaycastHit)(ref rayHit)).point, Color.yellow);
			}
			else
			{
				FX_Manager.EffectTargetPosition = __instance.MuzzleAlign.position + __instance.MuzzleAlign.forward * 50f;
				Debug.DrawLine(__instance.MuzzleAlign.position, __instance.MuzzleAlign.position + __instance.MuzzleAlign.forward * 10f, Color.green);
			}
			Action onBulletFired = __instance.OnBulletFired;
			if (onBulletFired != null)
			{
				onBulletFired.Invoke();
			}
			((FX_EffectBase)SentryGunInstance_Firing_Bullets.s_tracerPool.AquireEffect()).Play((FX_Trigger)null, __instance.MuzzleAlign.position, Quaternion.LookRotation(SentryGunInstance_Firing_Bullets.s_weaponRayData.fireDir));
			EX_SpriteMuzzleFlash muzzleFlash = __instance.m_muzzleFlash;
			if ((Object)(object)muzzleFlash != (Object)null)
			{
				muzzleFlash.Play();
			}
			WeaponShellManager.EjectShell((ShellTypes)3, 1f, (float)Random.RandomRangeInt(3, 5), __instance.ShellEjectAlign);
			__instance.m_fireBulletTimer = Clock.Time + __instance.m_archetypeData.GetSentryShotDelay(__instance.m_core.Owner, targetIsTagged);
			return false;
		}

		[HarmonyPrefix]
		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(SentryGunInstance_Firing_Bullets), "UpdateFireShotgunSemi")]
		private static bool Pre_UpdateFireShotgunSemi(SentryGunInstance_Firing_Bullets __instance, bool isMaster, bool targetIsTagged)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			iSentrygunInstanceCore core = __instance.m_core;
			SentryGunInstance val = ((core != null) ? ((Il2CppObjectBase)core).TryCast<SentryGunInstance>() : null);
			LSSComp lSSComp = ((val != null) ? ((Component)val).gameObject.GetComponent<LSSComp>() : null);
			if ((Object)(object)lSSComp == (Object)null)
			{
				return true;
			}
			_ = lSSComp.LSS.State;
			if (Clock.Time > __instance.m_fireBulletTimer)
			{
				Vector3 position = __instance.MuzzleAlign.position;
				__instance.TriggerSingleFireAudio();
				for (int i = 0; i < __instance.m_archetypeData.ShotgunBulletCount; i++)
				{
					float num = __instance.m_segmentSize * (float)i;
					float num2 = 0f;
					float num3 = 0f;
					if (i > 0)
					{
						num2 += (float)__instance.m_archetypeData.ShotgunConeSize * Mathf.Cos(num);
						num3 += (float)__instance.m_archetypeData.ShotgunConeSize * Mathf.Sin(num);
					}
					WeaponHitData val3 = (SentryGunInstance_Firing_Bullets.s_weaponRayData = new WeaponHitData
					{
						maxRayDist = __instance.MaxRayDist,
						angOffsetX = num2,
						angOffsetY = num3,
						randomSpread = __instance.m_archetypeData.ShotgunBulletSpread,
						fireDir = __instance.MuzzleAlign.forward
					});
					if (Weapon.CastWeaponRay(__instance.MuzzleAlign, ref val3, position, LayerManager.MASK_SENTRYGUN_RAY))
					{
						SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = __instance.m_core.Owner;
						GameObject target = val.m_detection.Target;
						PlayerAgent val4 = ((target != null) ? target.GetComponent<PlayerAgent>() : null);
						if (val.m_detection.HasTarget && (Object)(object)val4 != (Object)null)
						{
							SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = val.m_detection.Target.GetComponent<PlayerAgent>();
						}
						else
						{
							SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = LocalPlayer.Agent;
						}
						SentryGunInstance_Firing_Bullets.s_weaponRayData.damage = (targetIsTagged ? (__instance.m_archetypeData.Damage * __instance.m_archetypeData.Sentry_DamageTagMulti) : __instance.m_archetypeData.Damage);
						SentryGunInstance_Firing_Bullets.s_weaponRayData.staggerMulti = __instance.m_archetypeData.GetSentryStaggerDamage(targetIsTagged);
						SentryGunInstance_Firing_Bullets.s_weaponRayData.precisionMulti = __instance.m_archetypeData.PrecisionDamageMulti;
						SentryGunInstance_Firing_Bullets.s_weaponRayData.damageFalloff = __instance.m_archetypeData.DamageFalloff;
						BulletWeapon.BulletHit(SentryGunInstance_Firing_Bullets.s_weaponRayData, isMaster, 0f, 0u, true);
						RaycastHit rayHit = SentryGunInstance_Firing_Bullets.s_weaponRayData.rayHit;
						FX_Manager.EffectTargetPosition = ((RaycastHit)(ref rayHit)).point;
					}
					else
					{
						FX_Manager.EffectTargetPosition = __instance.MuzzleAlign.position + __instance.MuzzleAlign.forward * 50f;
					}
					FX_Manager.PlayLocalVersion = false;
					((FX_EffectBase)SentryGunInstance_Firing_Bullets.s_tracerPool.AquireEffect()).Play((FX_Trigger)null, __instance.MuzzleAlign.position, Quaternion.LookRotation(SentryGunInstance_Firing_Bullets.s_weaponRayData.fireDir));
				}
				__instance.UpdateAmmo(-1);
				Action onBulletFired = __instance.OnBulletFired;
				if (onBulletFired != null)
				{
					onBulletFired.Invoke();
				}
				__instance.m_fireBulletTimer = Clock.Time + (targetIsTagged ? (__instance.m_archetypeData.ShotDelay * __instance.m_archetypeData.Sentry_ShotDelayTagMulti) : __instance.m_archetypeData.ShotDelay);
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class OnLSSSpawned
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(SentryGunInstance), "OnSpawn")]
		private static void Post_(SentryGunInstance __instance, pGearSpawnData spawnData)
		{
			string data = spawnData.gearIDRange.publicName.data;
			if (data.StartsWith("E0$L$$"))
			{
				List<LSS> lSSInstances = LevelSpawnedSentryManager.Current.LSSInstances;
				if (!int.TryParse(data.Split('_')[1], out var result) || result < 0 || result >= lSSInstances.Count)
				{
					EOSLogger.Error("SentryGunInstance.OnSpawn: got publicName '" + data + "' with in valid instanceIndex");
					return;
				}
				LSS lSS = lSSInstances[result];
				LevelSpawnedSentryManager.Current.LSSInstances[result].AssignInstance(((Component)__instance).gameObject.AddComponent<LSSComp>().Setup(lSS));
				((Behaviour)((Il2CppObjectBase)((Item)__instance).PickupInteraction).Cast<Interact_Timed>()).enabled = false;
				Dimension.RemoveWarpable(((Il2CppObjectBase)__instance).Cast<IWarpableObject>());
				EOSLogger.Warning("LSS OnSpawn: " + lSS.Def.WorldEventObjectFilter);
			}
		}
	}
	[HarmonyPatch]
	internal static class OnSetup
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(SentryGunInstance), "CheckIsSetup")]
		private static void Post_CheckSetup(SentryGunInstance __instance)
		{
			LSSComp component = ((Component)__instance).gameObject.GetComponent<LSSComp>();
			if ((Object)(object)component != (Object)null)
			{
				EOSLogger.Warning("LSS CheckSetup: " + component.Def.WorldEventObjectFilter);
				component.UpdateVisuals();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SentryGunInstance_Detection), "Setup")]
		private static void Post_D_Setup(SentryGunInstance_Detection __instance)
		{
			SentryGunInstance obj = ((Il2CppObjectBase)__instance.m_core).TryCast<SentryGunInstance>();
			LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
			if (!((Object)(object)lSSComp == (Object)null))
			{
				__instance.m_targetPlayers = lSSComp.LSS.State.TargetPlayer;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SentryGunInstance_ScannerVisuals_Plane), "Setup")]
		private static void Post_V_Setup(SentryGunInstance_ScannerVisuals_Plane __instance)
		{
			if ((Object)(object)__instance.m_scannerPlane == (Object)null || (Object)(object)__instance.m_targetingAlign == (Object)null)
			{
				EOSLogger.Error("SentryGunInstance_ScannerVisuals_Plane.Setup: got a null scannerPlane / targetingAlign?");
			}
			SentryGunInstance obj = ((Il2CppObjectBase)__instance.m_core).TryCast<SentryGunInstance>();
			LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
			if (!((Object)(object)lSSComp == (Object)null))
			{
				lSSComp.UpdateVisuals();
			}
		}
	}
	[HarmonyPatch]
	internal static class OnPlayerGuiLayerSetup
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerGuiLayer), "Setup")]
		private static void Post_(PlayerGuiLayer __instance, Transform root, string name)
		{
			PlayerGUIMessageManager.Current.Setup(root);
		}
	}
	[HarmonyPatch]
	internal static class ReceiveToolRefill
	{
	}
	[HarmonyPatch]
	[HarmonyPatch]
	[HarmonyPatch]
	internal static class Targeting
	{
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(SentryGunInstance_Sync), "UpdateMaster")]
		private static void Post_UpdateMaster(SentryGunInstance_Sync __instance)
		{
			if (!(Clock.Time - __instance.m_lastSyncTime <= 0.5f))
			{
				SentryGunInstance obj = ((Il2CppObjectBase)__instance.m_core).TryCast<SentryGunInstance>();
				LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
				if (!((Object)(object)lSSComp == (Object)null))
				{
					lSSComp.LSS.OnUpdateMaster();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(SentryGunInstance_Sync), "UpdateClient")]
		private static void Post_UpdateClient(SentryGunInstance_Sync __instance)
		{
			if (Clock.Time - __instance.m_lastSyncTime > __instance.m_syncTimeout)
			{
				SentryGunInstance obj = ((Il2CppObjectBase)__instance.m_core).TryCast<SentryGunInstance>();
				LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
				if (!((Object)(object)lSSComp == (Object)null))
				{
					lSSComp.LSS.OnTargetedPlayer(null);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SentryGunInstance), "UpdateMaster")]
		private static void Post_UpdateMaster(SentryGunInstance __instance)
		{
			LSSComp lSSComp = ((__instance != null) ? ((Component)__instance).gameObject.GetComponent<LSSComp>() : null);
			if ((Object)(object)lSSComp == (Object)null)
			{
				return;
			}
			if (!lSSComp.LSS.State.Enabled || !lSSComp.LSS.State.TargetPlayer || !__instance.m_detection.HasTarget || (Object)(object)__instance.m_detection.Target == (Object)null)
			{
				PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
				lSSComp.LSS.OnTargetedPlayer(null);
				return;
			}
			PlayerAgent component = __instance.m_detection.Target.GetComponent<PlayerAgent>();
			if ((Object)(object)component == (Object)null || lSSComp.AmmoDepleted)
			{
				PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
				lSSComp.LSS.OnTargetedPlayer(null);
				return;
			}
			if (((Agent)component).IsLocallyOwned)
			{
				PlayerGUIMessageManager.Current.OnLocalPlayerTargeted(lSSComp.LSS);
			}
			else
			{
				PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
			}
			lSSComp.LSS.OnTargetedPlayer(component);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SentryGunInstance), "UpdateClient")]
		private static void Post_UpdateClient(SentryGunInstance __instance)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			LSSComp lSSComp = ((__instance != null) ? ((Component)__instance).gameObject.GetComponent<LSSComp>() : null);
			if (!((Object)(object)lSSComp == (Object)null))
			{
				LocalPlayerAgent val = default(LocalPlayerAgent);
				if (!lSSComp.LSS.State.Enabled || !lSSComp.LSS.State.TargetPlayer || !__instance.m_sync.LastSyncData.hasTarget)
				{
					PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
				}
				else if (!LocalPlayer.TryGetLocalAgent(ref val))
				{
					EOSLogger.Error("Post_UpdateClient: Cannot get local player agent!");
				}
				else if (lSSComp.LSS.LastSyncedTargetedPlayer == ((PlayerAgent)val).Owner.PlayerSlotIndex())
				{
					PlayerGUIMessageManager.Current.OnLocalPlayerTargeted(lSSComp.LSS);
				}
				else
				{
					PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(SentryGunInstance), "WantToScan")]
		private static bool Pre_WantToScan(SentryGunInstance __instance, ref bool __result)
		{
			LSSComp component = ((Component)__instance).gameObject.GetComponent<LSSComp>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			if (!component.LSS.State.Enabled)
			{
				__result = false;
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(SentryGunInstance_Detection), "UpdateDetection")]
		private static bool Pre_UpdateDetection_OnlyTargetPlayer_Master(SentryGunInstance_Detection __instance)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			iSentrygunInstanceCore core = __instance.m_core;
			SentryGunInstance obj = ((core != null) ? ((Il2CppObjectBase)core).TryCast<SentryGunInstance>() : null);
			LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
			if ((Object)(object)obj == (Object)null || (Object)(object)lSSComp == (Object)null)
			{
				return true;
			}
			if (!lSSComp.LSS.State.Enabled)
			{
				PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
				return false;
			}
			if (lSSComp.LSS.State.TargetEnemy)
			{
				return true;
			}
			if (Clock.Time > __instance.m_scanningTimer)
			{
				_ = ((Component)__instance.DetectionSource).transform.forward;
				Vector3 position = ((Component)__instance.DetectionSource).transform.position;
				if (__instance.m_core.Ammo >= __instance.m_core.CostOfBullet)
				{
					__instance.Target = null;
					__instance.TargetAimTrans = null;
					__instance.TargetIsTagged = false;
					if (__instance.m_targetPlayers)
					{
						PlayerAgent val = SentryGunInstance_Detection.CheckForPlayerTarget(__instance.m_archetypeData, __instance.DetectionSource, __instance.Target);
						if ((Object)(object)val != (Object)null)
						{
							__instance.Target = ((Component)val).gameObject;
							__instance.TargetAimTrans = ((Agent)val).TentacleTarget;
						}
					}
				}
				if ((Object)(object)__instance.Target != (Object)null)
				{
					Vector3 position2 = __instance.Target.transform.position;
					if (!__instance.HasTarget)
					{
						__instance.HasTarget = true;
						Action onFoundTarget = __instance.OnFoundTarget;
						if (onFoundTarget != null)
						{
							onFoundTarget.Invoke();
						}
					}
					Debug.DrawLine(position, position2);
				}
				else
				{
					__instance.HasTarget = false;
					__instance.TargetIsTagged = false;
				}
			}
			return false;
		}
	}
}
namespace EOSExt.LevelSpawnedSentry.Impl
{
	public class LSSComp : MonoBehaviour
	{
		public LSS LSS { get; private set; }

		public LevelSpawnedSentryDefinition Def => LSS.Def;

		public SentryGunInstance_ScannerVisuals_Plane Visuals => ((Component)this).gameObject.GetComponent<SentryGunInstance_ScannerVisuals_Plane>();

		public SentryGunInstance Sentry => ((Component)this).gameObject.GetComponent<SentryGunInstance>();

		public NavMarker marker { get; private set; }

		public bool IsSetup => LSS != null;

		public bool AmmoDepleted
		{
			get
			{
				if (Sentry.Ammo < Sentry.CostOfBullet)
				{
					return !Sentry.m_ammoDepleatedWarning;
				}
				return false;
			}
		}

		internal LSSComp Setup(LSS lss)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!IsSetup)
			{
				LSS = lss;
				LevelSpawnedSentryDefinition def = Def;
				marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(((Component)this).gameObject);
				if ((Object)(object)marker != (Object)null)
				{
					Color scanningColor = LSS.GetScanningColor(def.InitialState.TargetEnemy, def.InitialState.TargetPlayer);
					marker.SetStyle((eNavMarkerStyle)0);
					marker.SetColor(scanningColor);
					marker.SetVisible(def.InitialState.Enabled);
					marker.SetTitle(LSS.GetMarkerText(def.InitialState.TargetEnemy, def.InitialState.TargetPlayer));
				}
				UpdateVisuals();
				SetCanRefill(def.InitialState.CanRefill);
			}
			return this;
		}

		public void SetCanRefill(bool canRefill)
		{
			Sentry.AmmoMaxCap = (canRefill ? Def.AmmoCap : 0f);
		}

		internal void OnStateChanged(LSSSyncState oldState, LSSSyncState newState, bool isRecall)
		{
			EOSLogger.Debug($"LSSOnStateChanged \"{Def.WorldEventObjectFilter}\"! OldState: [{oldState}], NewState: {newState}");
			SentryGunInstance sentry = Sentry;
			if (newState.Enabled)
			{
				sentry.m_isSetup = true;
				sentry.m_isScanning = false;
				sentry.m_startScanTimer = Clock.Time + sentry.m_initialScanDelay;
				if (!oldState.Enabled)
				{
					((ItemEquippable)sentry).Sound.Post(EVENTS.SENTRYGUN_LOW_AMMO_WARNING, true);
				}
			}
			else
			{
				if (sentry.m_isFiring)
				{
					sentry.StopFiring();
				}
				if (sentry.m_isScanning)
				{
					sentry.StopScanning();
				}
				sentry.m_isSetup = false;
				((ItemEquippable)sentry).Sound.Post(EVENTS.SENTRYGUN_STOP_ALL_LOOPS, true);
			}
			iSentrygunInstance_Detection detection = sentry.m_detection;
			SentryGunInstance_Detection val = ((detection != null) ? ((Il2CppObjectBase)detection).TryCast<SentryGunInstance_Detection>() : null);
			if ((Object)(object)val != (Object)null)
			{
				val.m_targetPlayers = newState.TargetPlayer;
			}
			SetCanRefill(newState.CanRefill);
			UpdateVisuals();
		}

		internal void UpdateVisuals()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			LSSSyncState state = LSS.State;
			SentryGunInstance_ScannerVisuals_Plane visuals = Visuals;
			Color color = (visuals.m_scanningColor = LSS.GetScanningColor(state.TargetEnemy, state.TargetPlayer));
			if (state.Enabled)
			{
				if (visuals.m_core != null)
				{
					visuals.SetVisualStatus((eSentryGunStatus)((!AmmoDepleted) ? 1 : 4), true);
				}
				if (state.MarkerVisible)
				{
					NavMarker obj = marker;
					if (obj != null)
					{
						obj.SetColor(color);
					}
					NavMarker obj2 = marker;
					if (obj2 != null)
					{
						obj2.SetVisible(true);
					}
					NavMarker obj3 = marker;
					if (obj3 != null)
					{
						obj3.SetTitle(LSS.GetMarkerText(state.TargetEnemy, state.TargetPlayer));
					}
				}
				else
				{
					NavMarker obj4 = marker;
					if (obj4 != null)
					{
						obj4.SetVisible(false);
					}
				}
			}
			else
			{
				if (visuals.m_core != null)
				{
					visuals.m_scannerPlane.SetColor(LSS.OffColor);
					visuals.UpdateLightProps(LSS.OffColor, false);
				}
				NavMarker obj5 = marker;
				if (obj5 != null)
				{
					obj5.SetVisible(false);
				}
			}
		}

		private void OnDestroy()
		{
			GuiManager.NavMarkerLayer.RemoveMarker(marker);
			marker = null;
		}

		static LSSComp()
		{
			ClassInjector.RegisterTypeInIl2Cpp<LSSComp>();
		}
	}
	public struct LSSTargeted
	{
		public int LSSInstanceIndex { get; set; }

		public int PlayerSlotIndex { get; set; }

		public LSSTargeted()
		{
			LSSInstanceIndex = -1;
			PlayerSlotIndex = -1;
		}

		public LSSTargeted(LSSTargeted o)
		{
			LSSInstanceIndex = -1;
			PlayerSlotIndex = -1;
			LSSInstanceIndex = o.LSSInstanceIndex;
			PlayerSlotIndex = o.PlayerSlotIndex;
		}
	}
}
namespace EOSExt.LevelSpawnedSentry.Definition
{
	public class LevelSpawnedSentryDefinition
	{
		public string WorldEventObjectFilter { get; set; } = string.Empty;


		public uint PlayerOfflineGearDBId { get; set; }

		public eDimensionIndex DimensionIndex { get; set; }

		public Vec3 Position { get; set; } = new Vec3();


		public Vec3 Rotation { get; set; } = new Vec3();


		public LSSState InitialState { get; set; } = new LSSState();


		public float InitialAmmo { get; set; } = 0.5f;


		public float AmmoCap { get; set; } = 1f;

	}
	public class LSSState
	{
		public bool Enabled { get; set; } = true;


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


		public bool TargetPlayer { get; set; }

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


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


		public LSSState()
		{
		}

		public LSSState(LSSSyncState o)
		{
			Enabled = o.Enabled;
			TargetEnemy = o.TargetEnemy;
			TargetPlayer = o.TargetPlayer;
			MarkerVisible = o.MarkerVisible;
			CanRefill = o.CanRefill;
		}

		public LSSState(LSSState o)
		{
			Enabled = o.Enabled;
			TargetEnemy = o.TargetEnemy;
			TargetPlayer = o.TargetPlayer;
			MarkerVisible = o.MarkerVisible;
			CanRefill = o.CanRefill;
		}

		public override string ToString()
		{
			return $"Enabled: {Enabled}, TargetEnemy/Player: {TargetEnemy}/{TargetPlayer}, CanRefill: {CanRefill}";
		}
	}
	public struct LSSSyncState
	{
		public bool Enabled { get; set; }

		public bool TargetEnemy { get; set; }

		public bool TargetPlayer { get; set; }

		public bool MarkerVisible { get; set; }

		public bool CanRefill { get; set; }

		public float Ammo { get; set; }

		public LSSSyncState()
		{
			Enabled = true;
			TargetEnemy = true;
			TargetPlayer = false;
			MarkerVisible = true;
			CanRefill = true;
			Ammo = 0.5f;
		}

		public LSSSyncState(LSSSyncState o)
		{
			Enabled = true;
			TargetEnemy = true;
			TargetPlayer = false;
			MarkerVisible = true;
			CanRefill = true;
			Ammo = 0.5f;
			Enabled = o.Enabled;
			TargetEnemy = o.TargetEnemy;
			TargetPlayer = o.TargetPlayer;
			MarkerVisible = o.MarkerVisible;
			CanRefill = o.CanRefill;
			Ammo = o.Ammo;
		}

		public LSSSyncState(LSSState o)
		{
			Enabled = true;
			TargetEnemy = true;
			TargetPlayer = false;
			MarkerVisible = true;
			CanRefill = true;
			Ammo = 0.5f;
			Enabled = o.Enabled;
			TargetEnemy = o.TargetEnemy;
			TargetPlayer = o.TargetPlayer;
			MarkerVisible = o.MarkerVisible;
			CanRefill = o.CanRefill;
		}

		public override string ToString()
		{
			return $"Enabled: {Enabled}, TargetEnemy/Player: {TargetEnemy}/{TargetPlayer}, CanRefill: {CanRefill}";
		}
	}
}