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 BepInEx;
using BepInEx.Configuration;
using DM;
using GamepadUI.StateManager.Core;
using HarmonyLib;
using InControl;
using Landfall.TABS;
using Landfall.TABS.AI;
using Landfall.TABS.AI.Components;
using Landfall.TABS.GameState;
using Landfall.TABS_Input;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using TFBGames;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("0.0.0.0")]
[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 FreeAim
{
	internal static class AimExclusionIcons
	{
		private static readonly Dictionary<string, Sprite> UnitIconCache = new Dictionary<string, Sprite>();

		internal static Sprite GetUnitIcon(UnitBlueprint blueprint)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (((blueprint != null) ? blueprint.Entity : null) == null)
			{
				return null;
			}
			string text = AimExclusionStore.Key(blueprint.Entity.GUID);
			if (string.IsNullOrEmpty(text))
			{
				return TryGetLoadedSprite(blueprint.Entity);
			}
			if (UnitIconCache.TryGetValue(text, out var value))
			{
				return value;
			}
			Sprite val = TryGetLoadedSprite(blueprint.Entity);
			if ((Object)(object)val != (Object)null)
			{
				UnitIconCache[text] = val;
			}
			return val;
		}

		internal static Sprite TryGetLoadedSprite(object entity)
		{
			if (entity == null)
			{
				return null;
			}
			try
			{
				object? obj = entity.GetType().GetProperty("SpriteIcon", BindingFlags.Instance | BindingFlags.Public)?.GetValue(entity, null);
				return (Sprite)((obj is Sprite) ? obj : null);
			}
			catch
			{
				return null;
			}
		}
	}
	internal static class AimExclusionMenu
	{
		private enum SourceFilter
		{
			All,
			BuiltIn,
			Custom
		}

		private enum CombatFilter
		{
			All,
			Melee,
			Ranged
		}

		private enum TextAlignment
		{
			Left = 513,
			Center
		}

		private class VirtualRow
		{
			internal GameObject Row;

			internal Image RowImage;

			internal Image IconImage;

			internal Component TextComponent;

			internal Button ExcludeButton;

			internal Button RangeButton;

			internal Button SpreadButton;

			internal Button VerticalButton;

			internal Button DashButton;

			internal AimExclusionStore.UnitEntry BoundEntry;

			internal int DataIndex = -1;
		}

		private class PanelLayoutMarker : MonoBehaviour
		{
			internal int Version;
		}

		private class SearchInputBehaviour : MonoBehaviour
		{
			private void Update()
			{
				HandleSearchInput();
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__47_0;

			public static UnityAction<Vector2> <>9__58_0;

			public static Action <>9__61_0;

			public static Action <>9__61_1;

			public static Action <>9__61_2;

			public static Action <>9__61_3;

			public static Action <>9__61_4;

			public static Action <>9__61_5;

			public static Action <>9__61_6;

			public static Action <>9__61_7;

			public static Action <>9__61_8;

			public static Action <>9__61_9;

			public static Action <>9__61_10;

			public static Action <>9__62_0;

			public static Action <>9__62_1;

			public static Action <>9__63_0;

			public static Action <>9__63_1;

			public static Func<AimExclusionStore.UnitEntry, string> <>9__72_1;

			public static Func<AimExclusionStore.UnitEntry, bool> <>9__84_0;

			public static UnityAction <>9__116_0;

			internal void <TryAddButton>b__47_0()
			{
				try
				{
					Open();
				}
				catch (Exception arg)
				{
					Plugin.LogWarning($"Aim exclusions: menu open failed: {arg}");
				}
			}

			internal void <EnsureScrollListener>b__58_0(Vector2 _)
			{
				BindVisibleRows();
			}

			internal void <BuildPanel>b__61_0()
			{
				AimExclusionStore.SetAllExcluded(excluded: true);
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_1()
			{
				AimExclusionStore.SetAllExcluded(excluded: false);
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_2()
			{
				AimExclusionStore.SetAllRangeGate(enabled: false);
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_3()
			{
				AimExclusionStore.SetAllRangeGate(enabled: true);
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_4()
			{
				AimExclusionStore.SetAllVolleySpread(enabled: false);
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_5()
			{
				AimExclusionStore.SetAllVolleySpread(enabled: true);
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_6()
			{
				AimExclusionStore.SetAllMeleeDash(enabled: false);
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_7()
			{
				AimExclusionStore.SetAllMeleeDash(enabled: true);
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_8()
			{
				AimExclusionStore.ResetToDefaults();
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_9()
			{
				AimExclusionStore.SetAllVerticalAim(enabled: false);
				Refresh(resetScroll: true);
			}

			internal void <BuildPanel>b__61_10()
			{
				AimExclusionStore.SetAllVerticalAim(enabled: true);
				Refresh(resetScroll: true);
			}

			internal void <BuildBattleDashKeySettingsRow>b__62_0()
			{
			}

			internal void <BuildBattleDashKeySettingsRow>b__62_1()
			{
				SetMenuInputEnabled(enabled: true);
				_listeningForBattleDashKey = true;
				UpdateBattleDashKeyButtonLabel();
			}

			internal void <BuildAutoShootKeySettingsRow>b__63_0()
			{
			}

			internal void <BuildAutoShootKeySettingsRow>b__63_1()
			{
				SetMenuInputEnabled(enabled: true);
				_listeningForAutoShootKey = true;
				UpdateAutoShootKeyButtonLabel();
			}

			internal string <RebuildFilteredEntries>b__72_1(AimExclusionStore.UnitEntry u)
			{
				return u.name;
			}

			internal bool <UpdateSummaryText>b__84_0(AimExclusionStore.UnitEntry u)
			{
				return u.excluded;
			}

			internal void <CreateSearchBox>b__116_0()
			{
				_searchFocused = true;
				UpdateSearchLabel();
			}
		}

		private const int PanelLayoutVersion = 16;

		private const float HeaderHeight = 448f;

		private const int RowPoolExtra = 4;

		private const int MinRowPoolSize = 12;

		private static readonly FieldInfo MainMenuButtonsContainerField = AccessTools.Field(typeof(MainMenuButtons), "m_ButtonsContainer");

		private const float RowHeight = 56f;

		private const float IconSize = 40f;

		private const float TextLeft = 56f;

		private const float ActionButtonWidth = 84f;

		private static readonly Color RowEven = new Color(0.11f, 0.11f, 0.11f, 0.92f);

		private static readonly Color RowOdd = new Color(0.145f, 0.145f, 0.145f, 0.92f);

		private static readonly Color RowExcluded = new Color(0.26f, 0.12f, 0.12f, 0.96f);

		private static readonly Color ActionOn = new Color(0.2f, 0.48f, 0.28f, 0.98f);

		private static readonly Color ActionOff = new Color(0.18f, 0.18f, 0.18f, 0.96f);

		private static readonly Color SubtitleColor = new Color(0.62f, 0.66f, 0.7f, 1f);

		private static GameObject _canvasRoot;

		private static Canvas _canvas;

		private static GameObject _panel;

		private static Transform _listRoot;

		private static ScrollRect _scroll;

		private static Component _searchText;

		private static Component _summaryText;

		private static Component _textTemplate;

		private static GameObject _menuButtonSource;

		private static GameObject _rowButtonTemplate;

		private static SearchInputBehaviour _searchInputBehaviour;

		private static bool _listeningForBattleDashKey;

		private static Button _battleDashKeyButton;

		private static Component _battleDashKeyLabel;

		private static bool _listeningForAutoShootKey;

		private static Button _autoShootKeyButton;

		private static Component _autoShootKeyLabel;

		private static string _search = "";

		private static bool _searchFocused;

		private static SourceFilter _sourceFilter = SourceFilter.All;

		private static CombatFilter _combatFilter = CombatFilter.All;

		private static bool _scrollListenerRegistered;

		private static int _firstVisibleIndex = -1;

		private static readonly List<AimExclusionStore.UnitEntry> FilteredEntries = new List<AimExclusionStore.UnitEntry>();

		private static readonly List<(Button button, SourceFilter filter)> SourceFilterChips = new List<(Button, SourceFilter)>();

		private static readonly List<(Button button, CombatFilter filter)> CombatFilterChips = new List<(Button, CombatFilter)>();

		private static readonly List<VirtualRow> RowPool = new List<VirtualRow>();

		internal static bool IsOpen
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		internal static void MainMenuButtons_Start_Postfix(MainMenuButtons __instance)
		{
			TryAddButton(__instance);
		}

		private static void TryAddButton(MainMenuButtons menu)
		{
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			if ((Object)(object)menu == (Object)null)
			{
				return;
			}
			object? obj = MainMenuButtonsContainerField?.GetValue(menu);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform val2 = FindMenuButtonRow(val);
			bool flag = false;
			if ((Object)(object)val2 == (Object)null)
			{
				RemoveStaleMenuButtons(((Component)menu).transform);
				Transform val3 = null;
				foreach (Transform item in val)
				{
					Transform val4 = item;
					if ((Object)(object)((Component)val4).GetComponentInChildren<Button>(true) != (Object)null)
					{
						val3 = val4;
						break;
					}
				}
				if ((Object)(object)val3 == (Object)null)
				{
					return;
				}
				GameObject val5 = Object.Instantiate<GameObject>(((Component)val3).gameObject, val, false);
				((Object)val5).name = "StayCombatFixAimButton";
				val5.SetActive(true);
				val2 = val5.transform;
				Button componentInChildren = ((Component)val2).GetComponentInChildren<Button>(true);
				if ((Object)(object)componentInChildren == (Object)null)
				{
					Object.Destroy((Object)(object)val5);
					return;
				}
				_menuButtonSource = ((Component)componentInChildren).gameObject;
				if ((Object)(object)_textTemplate == (Object)null)
				{
					_textTemplate = FindTmpText(val5);
				}
				DisableLocalization(val5);
				SetTmpText(val5, "Aim Exclusions");
				((UnityEventBase)componentInChildren.onClick).RemoveAllListeners();
				ButtonClickedEvent onClick = componentInChildren.onClick;
				object obj2 = <>c.<>9__47_0;
				if (obj2 == null)
				{
					UnityAction val6 = delegate
					{
						try
						{
							Open();
						}
						catch (Exception arg)
						{
							Plugin.LogWarning($"Aim exclusions: menu open failed: {arg}");
						}
					};
					<>c.<>9__47_0 = val6;
					obj2 = (object)val6;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj2);
				flag = true;
			}
			int num = val.childCount - 1;
			int num2 = -1;
			foreach (Transform item2 in val)
			{
				Transform val7 = item2;
				if (!((Object)(object)((Component)val7).GetComponentInChildren<MainMenuQuitGame>(true) == (Object)null))
				{
					num2 = val7.GetSiblingIndex();
					num = num2;
					break;
				}
			}
			int num3;
			if (!flag)
			{
				num3 = ((val2.GetSiblingIndex() != num) ? 1 : 0);
				if (num3 == 0)
				{
					goto IL_01de;
				}
			}
			else
			{
				num3 = 1;
			}
			val2.SetSiblingIndex(num);
			goto IL_01de;
			IL_01de:
			if (num3 != 0)
			{
				RectTransform val8 = (RectTransform)(object)((val is RectTransform) ? val : null);
				if ((Object)(object)val8 != (Object)null)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(val8);
				}
				RebuildMainMenuNavigation(menu);
			}
			if (flag)
			{
				Plugin.LogInfo($"Aim exclusions: main menu button at index {val2.GetSiblingIndex()} " + $"(quit={num2}, children={val.childCount})");
			}
		}

		private static Transform FindMenuButtonRow(Transform buttonsContainer)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if ((Object)(object)buttonsContainer == (Object)null)
			{
				return null;
			}
			foreach (Transform item in buttonsContainer)
			{
				Transform val = item;
				if (((Object)val).name == "StayCombatFixAimButton")
				{
					return val;
				}
			}
			return null;
		}

		private static void RemoveStaleMenuButtons(Transform menuRoot)
		{
			if ((Object)(object)menuRoot == (Object)null)
			{
				return;
			}
			List<Transform> list = new List<Transform>();
			Transform[] componentsInChildren = ((Component)menuRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == "StayCombatFixAimButton")
				{
					list.Add(val);
				}
			}
			foreach (Transform item in list)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
		}

		private static void RebuildMainMenuNavigation(MainMenuButtons menu)
		{
			try
			{
				AccessTools.Method(typeof(MainMenuButtons), "RebuildNavigation", (Type[])null, (Type[])null)?.Invoke(menu, null);
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Aim exclusions: failed to rebuild main menu navigation: " + ex.Message);
			}
		}

		internal static void NotifyContentChanged()
		{
			if (!IsOpen)
			{
				return;
			}
			try
			{
				Refresh();
			}
			catch (Exception arg)
			{
				Plugin.LogWarning($"Aim exclusions: refresh after content change failed: {arg}");
			}
		}

		internal static void Open()
		{
			AimExclusionStore.EnsureDiscovered(force: true);
			EnsurePanelReady();
			if ((Object)(object)_canvas != (Object)null)
			{
				((Behaviour)_canvas).enabled = true;
			}
			_panel.SetActive(true);
			SetMenuInputEnabled(enabled: true);
			try
			{
				Refresh(resetScroll: true);
				SyncScrollAreaBelowHeader();
			}
			catch (Exception arg)
			{
				Plugin.LogWarning($"Aim exclusions: refresh failed: {arg}");
			}
			Plugin.LogInfo("Aim exclusions: menu opened with " + AimExclusionStore.DiscoverySummary);
		}

		private static void CloseMenu()
		{
			_searchFocused = false;
			_listeningForBattleDashKey = false;
			_listeningForAutoShootKey = false;
			SetMenuInputEnabled(enabled: false);
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
			if ((Object)(object)_canvas != (Object)null)
			{
				((Behaviour)_canvas).enabled = false;
			}
		}

		private static void SetMenuInputEnabled(bool enabled)
		{
			if ((Object)(object)_searchInputBehaviour != (Object)null)
			{
				((Behaviour)_searchInputBehaviour).enabled = enabled;
			}
		}

		private static void SyncScrollAreaBelowHeader()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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)
			if ((Object)(object)_panel == (Object)null)
			{
				return;
			}
			Transform obj = _panel.transform.Find("Header");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			Transform obj2 = _panel.transform.Find("Scroll");
			RectTransform val2 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
			{
				Canvas.ForceUpdateCanvases();
				LayoutRebuilder.ForceRebuildLayoutImmediate(val);
				float preferredHeight = LayoutUtility.GetPreferredHeight(val);
				float[] obj3 = new float[3] { 448f, preferredHeight, 0f };
				Rect rect = val.rect;
				obj3[2] = ((Rect)(ref rect)).height;
				float num = Mathf.Max(obj3);
				rect = val.rect;
				if (preferredHeight > ((Rect)(ref rect)).height)
				{
					val.sizeDelta = new Vector2(0f, preferredHeight);
				}
				val2.offsetMin = new Vector2(24f, 28f);
				val2.offsetMax = new Vector2(-24f, 0f - (num + 6f));
			}
		}

		private static void EnsurePanelReady()
		{
			if ((Object)(object)_panel != (Object)null && TryResolvePanelReferences())
			{
				return;
			}
			if ((Object)(object)_panel != (Object)null)
			{
				PanelLayoutMarker component = _panel.GetComponent<PanelLayoutMarker>();
				if ((Object)(object)component != (Object)null && component.Version != 16)
				{
					DestroyPanelRoot();
				}
				else if (!TryResolvePanelReferences())
				{
					DestroyPanelRoot();
				}
			}
			if ((Object)(object)_panel == (Object)null)
			{
				BuildPanel();
			}
			else
			{
				TryResolvePanelReferences();
			}
		}

		private static bool TryResolvePanelReferences()
		{
			if ((Object)(object)_panel == (Object)null)
			{
				return false;
			}
			PanelLayoutMarker component = _panel.GetComponent<PanelLayoutMarker>();
			if ((Object)(object)component == (Object)null || component.Version != 16)
			{
				return false;
			}
			Transform obj = _panel.transform.Find("Scroll");
			_scroll = ((obj != null) ? ((Component)obj).GetComponent<ScrollRect>() : null);
			_listRoot = _panel.transform.Find("Scroll/Viewport/Content");
			if ((Object)(object)_scroll == (Object)null || (Object)(object)_listRoot == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_scroll.content == (Object)null)
			{
				? val = _scroll;
				Transform listRoot = _listRoot;
				((ScrollRect)val).content = (RectTransform)(object)((listRoot is RectTransform) ? listRoot : null);
			}
			Transform val2 = _panel.transform.Find("Header");
			if ((Object)(object)val2 != (Object)null)
			{
				Transform obj2 = val2.Find("Summary");
				_summaryText = FindTmpText((obj2 != null) ? ((Component)obj2).gameObject : null);
			}
			if ((Object)(object)_canvasRoot != (Object)null)
			{
				_canvas = _canvasRoot.GetComponent<Canvas>();
				_searchInputBehaviour = _canvasRoot.GetComponent<SearchInputBehaviour>();
			}
			EnsureScrollListener();
			return true;
		}

		private static void EnsureScrollListener()
		{
			if (!((Object)(object)_scroll == (Object)null) && !_scrollListenerRegistered)
			{
				((UnityEvent<Vector2>)(object)_scroll.onValueChanged).AddListener((UnityAction<Vector2>)delegate
				{
					BindVisibleRows();
				});
				_scrollListenerRegistered = true;
			}
		}

		private static void DestroyPanelRoot()
		{
			ClearRowPool();
			_scrollListenerRegistered = false;
			if ((Object)(object)_canvasRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasRoot);
			}
			_canvasRoot = null;
			_canvas = null;
			_panel = null;
			_listRoot = null;
			_scroll = null;
			_summaryText = null;
			_searchText = null;
			_rowButtonTemplate = null;
			_searchInputBehaviour = null;
			_firstVisibleIndex = -1;
			SourceFilterChips.Clear();
			CombatFilterChips.Clear();
		}

		private static void ClearRowPool()
		{
			foreach (VirtualRow item in RowPool)
			{
				if ((Object)(object)item?.Row != (Object)null)
				{
					Object.Destroy((Object)(object)item.Row);
				}
			}
			RowPool.Clear();
		}

		private static void BuildPanel()
		{
			//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_0010: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_0555: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0649: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("StayCombatFix Aim Exclusions");
			_canvasRoot = val;
			Object.DontDestroyOnLoad((Object)val);
			_canvas = val.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 20000;
			((Behaviour)_canvas).enabled = false;
			CanvasScaler obj = val.AddComponent<CanvasScaler>();
			obj.uiScaleMode = (ScaleMode)1;
			obj.referenceResolution = new Vector2(1280f, 720f);
			val.AddComponent<GraphicRaycaster>();
			_searchInputBehaviour = val.AddComponent<SearchInputBehaviour>();
			((Behaviour)_searchInputBehaviour).enabled = false;
			_panel = CreatePanel(val.transform, "Panel", new Color(0.03f, 0.03f, 0.03f, 0.94f));
			_panel.AddComponent<PanelLayoutMarker>().Version = 16;
			RectTransform component = _panel.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.06f, 0.04f);
			component.anchorMax = new Vector2(0.94f, 0.96f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			BuildScrollArea();
			GameObject obj2 = CreatePanel(_panel.transform, "Header", new Color(0.03f, 0.03f, 0.03f, 0.98f));
			RectTransform component2 = obj2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 1f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(0.5f, 1f);
			component2.anchoredPosition = Vector2.zero;
			component2.sizeDelta = new Vector2(0f, 448f);
			((Graphic)obj2.GetComponent<Image>()).raycastTarget = false;
			VerticalLayoutGroup obj3 = obj2.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj3).padding = new RectOffset(12, 12, 8, 6);
			((HorizontalOrVerticalLayoutGroup)obj3).spacing = 6f;
			((HorizontalOrVerticalLayoutGroup)obj3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = false;
			CreateLayoutTextRow(obj2.transform, "Aim Exclusions", 32f, 26f, TextAlignment.Center);
			_summaryText = CreateLayoutTextRow(obj2.transform, string.Empty, 22f, 14f, TextAlignment.Center, null, "Summary");
			CreateLayoutTextRow(obj2.transform, "Exclude: disables crosshair aim and ballistic overrides while possessed.\nRange ON/OFF: out-of-range attack blocking (independent of Exclude).\nSpread ON/OFF: volley-style random projectile spread (requires crosshair aim).\nVert ON/OFF: mod weapon hold (crosshair tilt/PID on held weapons). Vert OFF: vanilla assigned hold positions only; crosshair attack aim and ballistic correction stay on.\nDash ON/OFF: melee body dash/lunge in first person (requires crosshair aim).\nSpread/Dash row buttons depend on unit combat type (Melee/Ranged/Mixed). Vert applies to every unit.\nIn-battle dash hotkey toggles dash for the possessed unit instance until the battle ends.\nBulk buttons apply to every discovered unit. Search supports tag:custom tag:melee etc.", 104f, 12f, TextAlignment.Left, SubtitleColor, "Guide");
			Transform parent = CreateHeaderLayoutRow(obj2.transform, "Toolbar", 36f);
			CreateSearchBox(parent, new Vector2(0f, 0f), new Vector2(520f, 34f));
			CreateButton(parent, "Close", new Vector2(-24f, 0f), new Vector2(120f, 36f), CloseMenu, anchorRight: true);
			BuildFilterToolbar(obj2.transform);
			Transform parent2 = CreateHeaderLayoutRow(obj2.transform, "BulkToolbar1", 36f);
			CreateButton(parent2, "Exclude All", new Vector2(0f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllExcluded(excluded: true);
				Refresh(resetScroll: true);
			});
			CreateButton(parent2, "Unexclude All", new Vector2(158f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllExcluded(excluded: false);
				Refresh(resetScroll: true);
			});
			CreateButton(parent2, "Range Off All", new Vector2(316f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllRangeGate(enabled: false);
				Refresh(resetScroll: true);
			});
			CreateButton(parent2, "Range On All", new Vector2(474f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllRangeGate(enabled: true);
				Refresh(resetScroll: true);
			});
			Transform parent3 = CreateHeaderLayoutRow(obj2.transform, "BulkToolbar2", 36f);
			CreateButton(parent3, "Spread Off All", new Vector2(0f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllVolleySpread(enabled: false);
				Refresh(resetScroll: true);
			});
			CreateButton(parent3, "Spread On All", new Vector2(158f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllVolleySpread(enabled: true);
				Refresh(resetScroll: true);
			});
			CreateButton(parent3, "Dash Off All", new Vector2(316f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllMeleeDash(enabled: false);
				Refresh(resetScroll: true);
			});
			CreateButton(parent3, "Dash On All", new Vector2(474f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllMeleeDash(enabled: true);
				Refresh(resetScroll: true);
			});
			CreateButton(parent3, "Reset Defaults", new Vector2(632f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.ResetToDefaults();
				Refresh(resetScroll: true);
			});
			Transform parent4 = CreateHeaderLayoutRow(obj2.transform, "BulkToolbar3", 36f);
			CreateButton(parent4, "Vert Off All", new Vector2(0f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllVerticalAim(enabled: false);
				Refresh(resetScroll: true);
			});
			CreateButton(parent4, "Vert On All", new Vector2(158f, 0f), new Vector2(150f, 34f), delegate
			{
				AimExclusionStore.SetAllVerticalAim(enabled: true);
				Refresh(resetScroll: true);
			});
			BuildBattleDashKeySettingsRow(obj2.transform);
			BuildAutoShootKeySettingsRow(obj2.transform);
			obj2.transform.SetAsLastSibling();
			EnsureRowButtonTemplate(val.transform);
			EnsureScrollListener();
			SyncScrollAreaBelowHeader();
			_panel.SetActive(false);
		}

		private static void BuildBattleDashKeySettingsRow(Transform header)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0055: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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)
			Transform parent = CreateHeaderLayoutRow(header, "SettingsToolbar", 36f);
			_battleDashKeyLabel = CreateLabel(parent, "In-battle dash toggle key:", 14f, TextAlignment.Left, new Vector2(0f, 0f), new Vector2(220f, 34f), stretch: false, layoutChild: false, SubtitleColor);
			_battleDashKeyButton = CreateButton(parent, AimExclusionStore.FormatKeyName(AimExclusionStore.GetBattleDashToggleKey()), new Vector2(228f, 0f), new Vector2(120f, 34f), delegate
			{
			});
			CreateButton(parent, "Change Key", new Vector2(356f, 0f), new Vector2(120f, 34f), delegate
			{
				SetMenuInputEnabled(enabled: true);
				_listeningForBattleDashKey = true;
				UpdateBattleDashKeyButtonLabel();
			});
			UpdateBattleDashKeyButtonLabel();
		}

		private static void BuildAutoShootKeySettingsRow(Transform header)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0055: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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)
			Transform parent = CreateHeaderLayoutRow(header, "AutoShootSettingsToolbar", 36f);
			_autoShootKeyLabel = CreateLabel(parent, "In-battle auto-shoot toggle key:", 14f, TextAlignment.Left, new Vector2(0f, 0f), new Vector2(220f, 34f), stretch: false, layoutChild: false, SubtitleColor);
			_autoShootKeyButton = CreateButton(parent, AimExclusionStore.FormatKeyName(AimExclusionStore.GetAutoShootToggleKey()), new Vector2(228f, 0f), new Vector2(120f, 34f), delegate
			{
			});
			CreateButton(parent, "Change Key", new Vector2(356f, 0f), new Vector2(120f, 34f), delegate
			{
				SetMenuInputEnabled(enabled: true);
				_listeningForAutoShootKey = true;
				UpdateAutoShootKeyButtonLabel();
			});
			UpdateAutoShootKeyButtonLabel();
		}

		private static void UpdateAutoShootKeyButtonLabel()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_autoShootKeyButton == (Object)null))
			{
				string value = (_listeningForAutoShootKey ? "Press key..." : AimExclusionStore.FormatKeyName(AimExclusionStore.GetAutoShootToggleKey()));
				SetTmpText(((Component)_autoShootKeyButton).gameObject, value);
			}
		}

		private static void UpdateBattleDashKeyButtonLabel()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_battleDashKeyButton == (Object)null))
			{
				string value = (_listeningForBattleDashKey ? "Press key..." : AimExclusionStore.FormatKeyName(AimExclusionStore.GetBattleDashToggleKey()));
				SetTmpText(((Component)_battleDashKeyButton).gameObject, value);
			}
		}

		private static void GetCombatToggleVisibility(bool? isRanged, out bool showSpread, out bool showVertical, out bool showDash)
		{
			showSpread = isRanged != false;
			showVertical = true;
			showDash = !isRanged.GetValueOrDefault();
		}

		private static float ActionButtonRightOffset(int slotFromRight)
		{
			return 0f - (84f * (float)(slotFromRight + 1) + 8f * (float)slotFromRight + 4f);
		}

		private static void LayoutRowActionButtons(VirtualRow virtualRow, AimExclusionStore.UnitEntry entry, out float textRightMargin)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			GetCombatToggleVisibility(entry?.isRanged, out var showSpread, out var showVertical, out var showDash);
			((Component)virtualRow.SpreadButton).gameObject.SetActive(showSpread);
			((Component)virtualRow.VerticalButton).gameObject.SetActive(showVertical);
			((Component)virtualRow.DashButton).gameObject.SetActive(showDash);
			List<Button> list = new List<Button> { virtualRow.ExcludeButton, virtualRow.RangeButton };
			if (showSpread)
			{
				list.Add(virtualRow.SpreadButton);
			}
			if (showVertical)
			{
				list.Add(virtualRow.VerticalButton);
			}
			if (showDash)
			{
				list.Add(virtualRow.DashButton);
			}
			for (int i = 0; i < list.Count; i++)
			{
				((Component)list[list.Count - 1 - i]).GetComponent<RectTransform>().anchoredPosition = new Vector2(ActionButtonRightOffset(i), -8f);
			}
			int count = list.Count;
			textRightMargin = 0f - (84f * (float)count + 8f * (float)Mathf.Max(0, count - 1) + 36f);
		}

		private static void BuildScrollArea()
		{
			//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_0020: 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)
			//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_0052: 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_0070: 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)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Scroll");
			val.transform.SetParent(_panel.transform, false);
			val.transform.SetAsFirstSibling();
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = new Vector2(24f, 28f);
			obj.offsetMax = new Vector2(-24f, -454f);
			ScrollRect val2 = val.AddComponent<ScrollRect>();
			GameObject val3 = CreatePanel(val.transform, "Viewport", new Color(0f, 0f, 0f, 0.22f));
			RectTransform component = val3.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			val3.AddComponent<RectMask2D>();
			GameObject val4 = new GameObject("Content");
			val4.transform.SetParent(val3.transform, false);
			_listRoot = val4.transform;
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = new Vector2(0f, 1f);
			val5.anchorMax = new Vector2(1f, 1f);
			val5.pivot = new Vector2(0.5f, 1f);
			val5.anchoredPosition = Vector2.zero;
			val5.sizeDelta = new Vector2(0f, 56f);
			val2.viewport = component;
			val2.content = val5;
			val2.horizontal = false;
			val2.vertical = true;
			val2.movementType = (MovementType)2;
			val2.scrollSensitivity = 30f;
			_scroll = val2;
		}

		private static void EnsureRowButtonTemplate(Transform parent)
		{
			if (!((Object)(object)_rowButtonTemplate != (Object)null) && !((Object)(object)_menuButtonSource == (Object)null))
			{
				_rowButtonTemplate = Object.Instantiate<GameObject>(_menuButtonSource, parent, false);
				((Object)_rowButtonTemplate).name = "RowButtonTemplate";
				_rowButtonTemplate.SetActive(false);
				DisableLocalization(_rowButtonTemplate);
				if ((Object)(object)_textTemplate == (Object)null)
				{
					_textTemplate = FindTmpText(_rowButtonTemplate);
				}
			}
		}

		private static void Refresh(bool resetScroll = false)
		{
			if (!TryResolvePanelReferences())
			{
				Plugin.LogWarning("Aim exclusions: list root missing; rebuilding panel");
				DestroyPanelRoot();
				BuildPanel();
				TryResolvePanelReferences();
				if ((Object)(object)_listRoot == (Object)null)
				{
					return;
				}
			}
			RebuildFilteredEntries();
			UpdateContentHeight(FilteredEntries.Count);
			UpdateSummaryText();
			UpdateFilterChipVisuals();
			if (resetScroll && (Object)(object)_scroll != (Object)null)
			{
				_scroll.verticalNormalizedPosition = 1f;
			}
			_firstVisibleIndex = -1;
			BindVisibleRows(force: true);
		}

		private static void RebuildFilteredEntries()
		{
			FilteredEntries.Clear();
			SourceFilter sourceFilter = _sourceFilter;
			CombatFilter combatFilter = _combatFilter;
			string textFilter = ParseSearchTags(ref sourceFilter, ref combatFilter);
			FilteredEntries.AddRange(from u in AimExclusionStore.Units
				where MatchesSource(u, sourceFilter) && MatchesCombat(u, combatFilter) && MatchesTextSearch(textFilter, u)
				orderby u.name
				select u);
		}

		private static string ParseSearchTags(ref SourceFilter sourceFilter, ref CombatFilter combatFilter)
		{
			string text = (_search ?? string.Empty).Trim();
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			string[] array = text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			List<string> list = new List<string>(array.Length);
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				if (!text2.StartsWith("tag:", StringComparison.OrdinalIgnoreCase))
				{
					list.Add(text2);
					continue;
				}
				switch (text2.Substring(4).Trim().ToLowerInvariant())
				{
				case "builtin":
				case "vanilla":
				case "built-in":
				case "official":
				case "mod":
					sourceFilter = SourceFilter.BuiltIn;
					break;
				case "custom":
					sourceFilter = SourceFilter.Custom;
					break;
				case "melee":
					combatFilter = CombatFilter.Melee;
					break;
				case "ranged":
					combatFilter = CombatFilter.Ranged;
					break;
				case "all":
					sourceFilter = SourceFilter.All;
					combatFilter = CombatFilter.All;
					break;
				default:
					list.Add(text2);
					break;
				}
			}
			return string.Join(" ", list).Trim().ToLowerInvariant();
		}

		private static bool MatchesSource(AimExclusionStore.UnitEntry entry, SourceFilter filter)
		{
			if (filter == SourceFilter.All)
			{
				return true;
			}
			bool flag = (entry?.source ?? "Built-in") == "Custom";
			return filter switch
			{
				SourceFilter.BuiltIn => !flag, 
				SourceFilter.Custom => flag, 
				_ => true, 
			};
		}

		private static bool MatchesCombat(AimExclusionStore.UnitEntry entry, CombatFilter filter)
		{
			switch (filter)
			{
			case CombatFilter.All:
				return true;
			case CombatFilter.Ranged:
				return entry?.isRanged.GetValueOrDefault() ?? false;
			default:
				if (entry == null)
				{
					return false;
				}
				return entry.isRanged == false;
			}
		}

		private static bool MatchesTextSearch(string filter, AimExclusionStore.UnitEntry entry)
		{
			if (string.IsNullOrEmpty(filter))
			{
				return true;
			}
			string text = AimExclusionStore.FormatCombatTag(entry?.isRanged);
			return Matches(filter, entry?.name, entry?.source, text);
		}

		private static void BuildFilterToolbar(Transform header)
		{
			//IL_0034: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			SourceFilterChips.Clear();
			CombatFilterChips.Clear();
			Transform parent = CreateHeaderLayoutRow(header, "FilterToolbar", 36f);
			RegisterSourceFilterChip(parent, "All", new Vector2(0f, 0f), SourceFilter.All);
			RegisterSourceFilterChip(parent, "Built-in", new Vector2(58f, 0f), SourceFilter.BuiltIn);
			RegisterSourceFilterChip(parent, "Custom", new Vector2(150f, 0f), SourceFilter.Custom);
			RegisterCombatFilterChip(parent, "Any", new Vector2(230f, 0f), CombatFilter.All);
			RegisterCombatFilterChip(parent, "Melee", new Vector2(290f, 0f), CombatFilter.Melee);
			RegisterCombatFilterChip(parent, "Ranged", new Vector2(358f, 0f), CombatFilter.Ranged);
			UpdateFilterChipVisuals();
		}

		private static void RegisterSourceFilterChip(Transform parent, string label, Vector2 position, SourceFilter filter)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Button val = CreateFilterChip(parent, label, position, delegate
			{
				SetSourceFilter(filter);
			});
			if ((Object)(object)val != (Object)null)
			{
				SourceFilterChips.Add((val, filter));
			}
		}

		private static void RegisterCombatFilterChip(Transform parent, string label, Vector2 position, CombatFilter filter)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Button val = CreateFilterChip(parent, label, position, delegate
			{
				SetCombatFilter(filter);
			});
			if ((Object)(object)val != (Object)null)
			{
				CombatFilterChips.Add((val, filter));
			}
		}

		private static void UpdateFilterChipVisuals()
		{
			foreach (var (button, sourceFilter) in SourceFilterChips)
			{
				SetActionButtonActive(button, _sourceFilter == sourceFilter);
			}
			foreach (var (button2, combatFilter) in CombatFilterChips)
			{
				SetActionButtonActive(button2, _combatFilter == combatFilter);
			}
		}

		private static void SetSourceFilter(SourceFilter filter)
		{
			_sourceFilter = filter;
			Refresh(resetScroll: true);
		}

		private static void SetCombatFilter(CombatFilter filter)
		{
			_combatFilter = filter;
			Refresh(resetScroll: true);
		}

		private static Button CreateFilterChip(Transform parent, string label, Vector2 position, Action onClick)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return CreateButton(parent, label, position, new Vector2(72f, 30f), onClick);
		}

		private static void UpdateSummaryText()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			int num = FilteredEntries.Count((AimExclusionStore.UnitEntry u) => u.excluded);
			int count = AimExclusionStore.Units.Count;
			SetText(_summaryText, $"Showing {FilteredEntries.Count} of {count} units · {num} excluded in list · {AimExclusionStore.DiscoverySummary}", (float?)14f, TextAlignment.Center, (Color?)new Color(0.78f, 0.8f, 0.84f, 1f), richText: false);
		}

		private static float GetViewportHeight()
		{
			//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)
			ScrollRect scroll = _scroll;
			if ((Object)(object)((scroll != null) ? scroll.viewport : null) != (Object)null)
			{
				Rect rect = _scroll.viewport.rect;
				return ((Rect)(ref rect)).height;
			}
			return 600f;
		}

		private static int GetRequiredPoolSize()
		{
			int num = Mathf.CeilToInt(GetViewportHeight() / 56f) + 4;
			return Mathf.Max(12, num);
		}

		private static void EnsureRowPool()
		{
			int requiredPoolSize = GetRequiredPoolSize();
			while (RowPool.Count < requiredPoolSize)
			{
				VirtualRow virtualRow = CreateVirtualRowShell();
				((Object)virtualRow.Row).name = "Row";
				virtualRow.Row.transform.SetParent(_listRoot, false);
				virtualRow.Row.SetActive(false);
				RowPool.Add(virtualRow);
			}
		}

		private static int GetFirstVisibleIndex()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Transform listRoot = _listRoot;
			RectTransform val = (RectTransform)(object)((listRoot is RectTransform) ? listRoot : null);
			if ((Object)(object)val == (Object)null)
			{
				return 0;
			}
			return Mathf.Max(0, Mathf.FloorToInt(val.anchoredPosition.y / 56f));
		}

		private static void BindVisibleRows(bool force = false)
		{
			if ((Object)(object)_listRoot == (Object)null)
			{
				return;
			}
			if (FilteredEntries.Count == 0)
			{
				foreach (VirtualRow item in RowPool)
				{
					if ((Object)(object)item?.Row != (Object)null)
					{
						item.Row.SetActive(false);
					}
				}
				_firstVisibleIndex = 0;
				return;
			}
			EnsureRowPool();
			int firstVisibleIndex = GetFirstVisibleIndex();
			if (!force && firstVisibleIndex == _firstVisibleIndex)
			{
				return;
			}
			_firstVisibleIndex = firstVisibleIndex;
			for (int i = 0; i < RowPool.Count; i++)
			{
				int num = firstVisibleIndex + i;
				VirtualRow virtualRow = RowPool[i];
				if (num >= FilteredEntries.Count)
				{
					virtualRow.DataIndex = -1;
					virtualRow.BoundEntry = null;
					virtualRow.Row.SetActive(false);
				}
				else
				{
					virtualRow.Row.SetActive(true);
					BindVirtualRow(virtualRow, FilteredEntries[num], num);
				}
			}
		}

		private static VirtualRow CreateVirtualRowShell()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			VirtualRow virtualRow = new VirtualRow();
			virtualRow.Row = CreatePanel(_listRoot, "Row", RowEven);
			virtualRow.RowImage = virtualRow.Row.GetComponent<Image>();
			GameObject val = CreatePanel(virtualRow.Row.transform, "IconFrame", new Color(0.07f, 0.07f, 0.07f, 1f));
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(8f, -8f);
			component.sizeDelta = new Vector2(40f, 40f);
			GameObject val2 = new GameObject("Icon");
			val2.transform.SetParent(val.transform, false);
			RectTransform obj = val2.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = new Vector2(3f, 3f);
			obj.offsetMax = new Vector2(-3f, -3f);
			virtualRow.IconImage = val2.AddComponent<Image>();
			virtualRow.IconImage.preserveAspect = true;
			((Graphic)virtualRow.IconImage).raycastTarget = false;
			virtualRow.TextComponent = CreateRowText(virtualRow.Row.transform, string.Empty, 18f, new Vector2(56f, 6f), new Vector2(-464f, -6f), richText: true);
			virtualRow.ExcludeButton = CreateRowActionButton(virtualRow.Row.transform, "Exclude", active: false, new Vector2(-456f, -8f), new Vector2(84f, 40f), delegate
			{
				OnExcludeClicked(virtualRow);
			});
			virtualRow.RangeButton = CreateRowActionButton(virtualRow.Row.transform, "Range ON", active: true, new Vector2(-364f, -8f), new Vector2(84f, 40f), delegate
			{
				OnRangeClicked(virtualRow);
			});
			virtualRow.SpreadButton = CreateRowActionButton(virtualRow.Row.transform, "Spread ON", active: true, new Vector2(-272f, -8f), new Vector2(84f, 40f), delegate
			{
				OnSpreadClicked(virtualRow);
			});
			virtualRow.VerticalButton = CreateRowActionButton(virtualRow.Row.transform, "Vert ON", active: true, new Vector2(-180f, -8f), new Vector2(84f, 40f), delegate
			{
				OnVerticalClicked(virtualRow);
			});
			virtualRow.DashButton = CreateRowActionButton(virtualRow.Row.transform, "Dash ON", active: true, new Vector2(-88f, -8f), new Vector2(84f, 40f), delegate
			{
				OnDashClicked(virtualRow);
			});
			return virtualRow;
		}

		private static void OnExcludeClicked(VirtualRow virtualRow)
		{
			AimExclusionStore.UnitEntry boundEntry = virtualRow.BoundEntry;
			if (boundEntry != null)
			{
				AimExclusionStore.SetUnitExcluded(boundEntry, !boundEntry.excluded);
				BindVirtualRow(virtualRow, boundEntry, virtualRow.DataIndex);
				UpdateSummaryText();
			}
		}

		private static void OnRangeClicked(VirtualRow virtualRow)
		{
			AimExclusionStore.UnitEntry boundEntry = virtualRow.BoundEntry;
			if (boundEntry != null)
			{
				AimExclusionStore.SetUnitRangeGate(boundEntry, !boundEntry.rangeGateEnabled);
				BindVirtualRow(virtualRow, boundEntry, virtualRow.DataIndex);
				UpdateSummaryText();
			}
		}

		private static void OnSpreadClicked(VirtualRow virtualRow)
		{
			AimExclusionStore.UnitEntry boundEntry = virtualRow.BoundEntry;
			if (boundEntry != null)
			{
				AimExclusionStore.SetUnitVolleySpread(boundEntry, !boundEntry.volleySpreadEnabled);
				BindVirtualRow(virtualRow, boundEntry, virtualRow.DataIndex);
				UpdateSummaryText();
			}
		}

		private static void OnVerticalClicked(VirtualRow virtualRow)
		{
			AimExclusionStore.UnitEntry boundEntry = virtualRow.BoundEntry;
			if (boundEntry != null)
			{
				AimExclusionStore.SetUnitVerticalAim(boundEntry, !boundEntry.verticalAimEnabled);
				BindVirtualRow(virtualRow, boundEntry, virtualRow.DataIndex);
				UpdateSummaryText();
			}
		}

		private static void OnDashClicked(VirtualRow virtualRow)
		{
			AimExclusionStore.UnitEntry boundEntry = virtualRow.BoundEntry;
			if (boundEntry != null)
			{
				AimExclusionStore.SetUnitMeleeDash(boundEntry, !boundEntry.meleeDashEnabled);
				BindVirtualRow(virtualRow, boundEntry, virtualRow.DataIndex);
				UpdateSummaryText();
			}
		}

		private static void BindVirtualRow(VirtualRow virtualRow, AimExclusionStore.UnitEntry entry, int dataIndex)
		{
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			virtualRow.BoundEntry = entry;
			virtualRow.DataIndex = dataIndex;
			ConfigureListRowRect(virtualRow.Row, dataIndex);
			ApplyRowHighlight(virtualRow.Row, entry.excluded, dataIndex);
			AimExclusionStore.EnsureEntryIcon(entry);
			if ((Object)(object)virtualRow.IconImage != (Object)null)
			{
				virtualRow.IconImage.sprite = entry.iconSprite;
				((Behaviour)virtualRow.IconImage).enabled = (Object)(object)entry.iconSprite != (Object)null;
			}
			SetActionButtonActive(virtualRow.ExcludeButton, entry.excluded);
			SetActionButtonActive(virtualRow.RangeButton, entry.rangeGateEnabled);
			SetTmpText(((Component)virtualRow.RangeButton).gameObject, entry.rangeGateEnabled ? "Range ON" : "Range OFF");
			GetCombatToggleVisibility(entry.isRanged, out var showSpread, out var showVertical, out var showDash);
			if (showSpread)
			{
				SetActionButtonActive(virtualRow.SpreadButton, entry.volleySpreadEnabled);
				SetTmpText(((Component)virtualRow.SpreadButton).gameObject, entry.volleySpreadEnabled ? "Spread ON" : "Spread OFF");
			}
			if (showVertical)
			{
				SetActionButtonActive(virtualRow.VerticalButton, entry.verticalAimEnabled);
				SetTmpText(((Component)virtualRow.VerticalButton).gameObject, entry.verticalAimEnabled ? "Vert ON" : "Vert OFF");
			}
			if (showDash)
			{
				SetActionButtonActive(virtualRow.DashButton, entry.meleeDashEnabled);
				SetTmpText(((Component)virtualRow.DashButton).gameObject, entry.meleeDashEnabled ? "Dash ON" : "Dash OFF");
			}
			LayoutRowActionButtons(virtualRow, entry, out var textRightMargin);
			if ((Object)(object)virtualRow.TextComponent != (Object)null)
			{
				RectTransform component = virtualRow.TextComponent.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.offsetMax = new Vector2(textRightMargin, -6f);
				}
			}
			SetText(virtualRow.TextComponent, FormatUnitRichText(entry), 18f, TextAlignment.Left, Color.white, richText: true);
		}

		private static bool Matches(string filter, params string[] values)
		{
			if (!string.IsNullOrEmpty(filter))
			{
				return values.Any((string v) => (v ?? string.Empty).ToLowerInvariant().Contains(filter));
			}
			return true;
		}

		private static void UpdateContentHeight(int rowCount)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Transform listRoot = _listRoot;
			RectTransform val = (RectTransform)(object)((listRoot is RectTransform) ? listRoot : null);
			if (!((Object)(object)val == (Object)null))
			{
				val.sizeDelta = new Vector2(0f, Mathf.Max(56f, (float)rowCount * 56f + 16f));
				val.anchoredPosition = Vector2.zero;
			}
		}

		private static Button CreateRowActionButton(Transform parent, string label, bool active, Vector2 anchoredPosition, Vector2 size, Action onClick)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CreateRowButton(parent, label, anchoredPosition, size, onClick, anchorRight: true);
			SetActionButtonActive(obj, active);
			return obj;
		}

		private static void SetActionButtonActive(Button button, bool active)
		{
			//IL_0025: 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)
			if (!((Object)(object)button == (Object)null))
			{
				Image component = ((Component)button).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (active ? ActionOn : ActionOff);
				}
			}
		}

		private static void ApplyRowHighlight(GameObject row, bool excluded, int rowIndex)
		{
			//IL_0031: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)row == (Object)null))
			{
				Image component = row.GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (excluded ? RowExcluded : ((rowIndex % 2 == 0) ? RowEven : RowOdd));
				}
			}
		}

		private static void ConfigureListRowRect(GameObject row, int rowIndex)
		{
			//IL_0011: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = row.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, (float)(-rowIndex) * 56f);
			component.sizeDelta = new Vector2(0f, 56f);
		}

		private static string FormatUnitRichText(AimExclusionStore.UnitEntry entry)
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			string value = HumanizeName(string.IsNullOrWhiteSpace(entry.name) ? entry.guid : entry.name);
			string value2 = (string.IsNullOrWhiteSpace(entry.source) ? "Unknown" : entry.source);
			string value3 = AimExclusionStore.FormatCombatTag(entry.isRanged);
			string text = (entry.rangeGateEnabled ? string.Empty : " · range gate off");
			GetCombatToggleVisibility(entry.isRanged, out var showSpread, out var showVertical, out var showDash);
			if (showSpread && !entry.volleySpreadEnabled)
			{
				text += " · spread off";
			}
			if (showVertical && !entry.verticalAimEnabled)
			{
				text += " · vert off";
			}
			if (showDash && !entry.meleeDashEnabled)
			{
				text += " · dash off";
			}
			return "<size=18>" + EscapeRichText(value) + "</size>\n<size=13><color=#" + ColorToHex(SubtitleColor) + ">" + EscapeRichText(value2) + " · " + EscapeRichText(value3) + text + "</color></size>";
		}

		private static string HumanizeName(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "Unknown";
			}
			string text = value;
			if (text.StartsWith("UNIT_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(5);
			}
			return text.Replace('_', ' ');
		}

		private static string EscapeRichText(string value)
		{
			return (value ?? string.Empty).Replace("<", "\\<").Replace(">", "\\>");
		}

		private static string ColorToHex(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ColorUtility.ToHtmlStringRGB(color);
		}

		private static Button CreateRowButton(Transform parent, string label, Vector2 anchoredPosition, Vector2 size, Action onClick, bool anchorRight = false)
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_004d: 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_0077: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			if ((Object)(object)_rowButtonTemplate != (Object)null)
			{
				GameObject obj = Object.Instantiate<GameObject>(_rowButtonTemplate, parent, false);
				obj.SetActive(true);
				DisableLocalization(obj);
				RectTransform component = obj.GetComponent<RectTransform>();
				if (anchorRight)
				{
					component.anchorMin = new Vector2(1f, 1f);
					component.anchorMax = new Vector2(1f, 1f);
					component.pivot = new Vector2(1f, 1f);
				}
				else
				{
					component.anchorMin = new Vector2(0f, 1f);
					component.anchorMax = new Vector2(0f, 1f);
					component.pivot = new Vector2(0f, 1f);
				}
				component.anchoredPosition = anchoredPosition;
				component.sizeDelta = size;
				Button component2 = obj.GetComponent<Button>();
				((UnityEventBase)component2.onClick).RemoveAllListeners();
				if (onClick != null)
				{
					((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
					{
						onClick();
					});
				}
				SetTmpText(obj, label);
				ConfigureRowButtonHitArea(obj);
				return component2;
			}
			return CreateButton(parent, label, anchoredPosition, size, onClick, anchorRight);
		}

		private static void ConfigureRowButtonHitArea(GameObject buttonObject)
		{
			if ((Object)(object)buttonObject == (Object)null)
			{
				return;
			}
			Image component = buttonObject.GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).raycastTarget = true;
			}
			Component[] componentsInChildren = buttonObject.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((object)val).GetType().Name;
					if (!(name != "TextMeshProUGUI") || !(name != "TMP_Text"))
					{
						StretchTextRect(val);
						((object)val).GetType().GetProperty("raycastTarget")?.SetValue(val, false, null);
					}
				}
			}
		}

		private static Component CreateRowText(Transform parent, string value, float size, Vector2 offsetMin, Vector2 offsetMax, bool richText = false)
		{
			//IL_00c9: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_textTemplate != (Object)null)
			{
				GameObject obj = Object.Instantiate<GameObject>(_textTemplate.gameObject, parent, false);
				obj.SetActive(true);
				DisableLocalization(obj);
				RectTransform component = obj.GetComponent<RectTransform>();
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.one;
				component.pivot = new Vector2(0.5f, 0.5f);
				component.offsetMin = offsetMin;
				component.offsetMax = offsetMax;
				Component val = FindTmpText(obj);
				SetText(val, value, size, TextAlignment.Left, Color.white, richText);
				if ((Object)(object)val != (Object)null)
				{
					((object)val).GetType().GetProperty("raycastTarget")?.SetValue(val, false, null);
				}
				return val;
			}
			return CreateLabel(parent, value, size, TextAlignment.Left);
		}

		private static GameObject CreatePanel(Transform parent, string name, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			((Graphic)val.AddComponent<Image>()).color = color;
			return val;
		}

		private static Transform CreateHeaderLayoutRow(Transform parent, string name, float height)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = height;
			obj.minHeight = height;
			obj.flexibleWidth = 1f;
			return val.transform;
		}

		private static Component CreateLayoutTextRow(Transform parent, string value, float height, float fontSize, TextAlignment alignment, Color? color = null, string name = null)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(string.IsNullOrEmpty(name) ? "TextRow" : name);
			val.transform.SetParent(parent, false);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = height;
			obj.minHeight = height;
			obj.flexibleWidth = 1f;
			GameObject val2 = new GameObject("Text");
			val2.transform.SetParent(val.transform, false);
			RectTransform obj2 = val2.AddComponent<RectTransform>();
			obj2.anchorMin = Vector2.zero;
			obj2.anchorMax = Vector2.one;
			obj2.offsetMin = new Vector2(4f, 0f);
			obj2.offsetMax = new Vector2(-4f, 0f);
			Component val3 = AddTmpText(val2);
			ConfigureLabelText(val3, fontSize, alignment);
			SetText(val3, value, fontSize, alignment, (Color)(((??)color) ?? Color.white), value.Contains("\n"));
			StretchTextRect(val3);
			if ((Object)(object)val3 != (Object)null)
			{
				((object)val3).GetType().GetProperty("raycastTarget")?.SetValue(val3, false, null);
			}
			return val3;
		}

		private static void ConfigureLabelText(Component tmp, float size, TextAlignment alignment)
		{
			if (!((Object)(object)tmp == (Object)null))
			{
				Type type = ((object)tmp).GetType();
				type.GetProperty("enableAutoSizing")?.SetValue(tmp, false, null);
				type.GetProperty("fontSize")?.SetValue(tmp, size, null);
				type.GetProperty("enableWordWrapping")?.SetValue(tmp, true, null);
				PropertyInfo property = type.GetProperty("alignment");
				if (property != null)
				{
					property.SetValue(tmp, Enum.ToObject(property.PropertyType, (int)alignment), null);
				}
			}
		}

		private static Component CreateLabel(Transform parent, string value, float size, TextAlignment alignment, Vector2 pos = default(Vector2), Vector2 sizeDelta = default(Vector2), bool stretch = false, bool layoutChild = false, Color? color = null)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_0047: 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)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_00e1: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Label");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			if (layoutChild)
			{
				ConfigureLayoutChildRect(val2, -1f, 36f, flexibleWidth: true);
			}
			else if (stretch)
			{
				val2.anchorMin = new Vector2(0f, 1f);
				val2.anchorMax = new Vector2(1f, 1f);
				val2.pivot = new Vector2(0.5f, 1f);
				val2.anchoredPosition = pos;
				val2.sizeDelta = sizeDelta;
			}
			else
			{
				val2.anchorMin = new Vector2(0f, 1f);
				val2.anchorMax = new Vector2(0f, 1f);
				val2.pivot = new Vector2(0f, 1f);
				val2.anchoredPosition = pos;
				val2.sizeDelta = sizeDelta;
			}
			Component val3 = AddTmpText(val);
			SetText(val3, value, size, alignment, (Color)(((??)color) ?? Color.white));
			StretchTextRect(val3);
			if ((Object)(object)val3 != (Object)null)
			{
				((object)val3).GetType().GetProperty("raycastTarget")?.SetValue(val3, false, null);
			}
			return val3;
		}

		private static Button CreateButton(Transform parent, string label, Vector2 pos, Vector2 size, Action click, bool anchorRight = false, bool layoutChild = false)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_007c: 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)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_00a6: 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)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: 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)
			//IL_018c: 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)
			GameObject val = CreatePanel(parent, label + "Button", new Color(0.18f, 0.18f, 0.18f, 0.96f));
			RectTransform component = val.GetComponent<RectTransform>();
			if (layoutChild)
			{
				ConfigureLayoutChildRect(component, size.x, size.y);
			}
			else
			{
				component.anchorMin = (anchorRight ? new Vector2(1f, 1f) : new Vector2(0f, 1f));
				component.anchorMax = (anchorRight ? new Vector2(1f, 1f) : new Vector2(0f, 1f));
				component.pivot = (anchorRight ? new Vector2(1f, 1f) : new Vector2(0f, 1f));
				component.anchoredPosition = pos;
				component.sizeDelta = size;
			}
			Button val2 = val.AddComponent<Button>();
			if (click != null)
			{
				((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
				{
					click();
				});
			}
			CreateLabel(val.transform, label, 18f, TextAlignment.Center, Vector2.zero, Vector2.zero, stretch: true);
			Component val3 = FindTmpText(val);
			RectTransform val4 = (((Object)(object)val3 != (Object)null) ? val3.GetComponent<RectTransform>() : null);
			if ((Object)(object)val4 != (Object)null && (Object)(object)((Component)val4).gameObject != (Object)(object)val)
			{
				val4.anchorMin = Vector2.zero;
				val4.anchorMax = Vector2.one;
				val4.offsetMin = Vector2.zero;
				val4.offsetMax = Vector2.zero;
			}
			return val2;
		}

		private static void CreateSearchBox(Transform parent, Vector2 pos, Vector2 size)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_0060: 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)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00dd: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			GameObject val = CreatePanel(parent, "Search", new Color(0.14f, 0.14f, 0.14f, 1f));
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = pos;
			component.sizeDelta = size;
			GameObject val2 = new GameObject("Text");
			val2.transform.SetParent(val.transform, false);
			RectTransform obj = val2.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = new Vector2(8f, 2f);
			obj.offsetMax = new Vector2(-8f, -2f);
			_searchText = AddTmpText(val2);
			UpdateSearchLabel();
			ButtonClickedEvent onClick = val.AddComponent<Button>().onClick;
			object obj2 = <>c.<>9__116_0;
			if (obj2 == null)
			{
				UnityAction val3 = delegate
				{
					_searchFocused = true;
					UpdateSearchLabel();
				};
				<>c.<>9__116_0 = val3;
				obj2 = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj2);
		}

		private static Component AddTmpText(GameObject obj)
		{
			Type type = AccessTools.TypeByName("TMPro.TextMeshProUGUI");
			if (type == null)
			{
				throw new MissingMemberException("TextMeshProUGUI type not found");
			}
			Component obj2 = obj.AddComponent(type);
			CopyTextTemplate(obj2);
			return obj2;
		}

		private static Component FindTmpText(GameObject root)
		{
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((object)val).GetType().Name;
					if (name == "TextMeshProUGUI" || name == "TMP_Text")
					{
						return val;
					}
				}
			}
			return null;
		}

		private static void SetTmpText(GameObject root, string value)
		{
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((object)val).GetType().Name;
					if (name == "TextMeshProUGUI" || name == "TMP_Text")
					{
						SetText(val, value, null, TextAlignment.Center);
					}
				}
			}
		}

		private static void DisableLocalization(GameObject root)
		{
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !(((object)val).GetType().Name != "LocalizeText"))
				{
					Type type = ((object)val).GetType();
					type.GetProperty("Localized")?.SetValue(val, false, null);
					type.GetProperty("LocaleID")?.SetValue(val, "", null);
					Behaviour val2 = (Behaviour)(object)((val is Behaviour) ? val : null);
					if (val2 != null)
					{
						val2.enabled = false;
					}
				}
			}
		}

		private static void SetText(Component component, string value, float? size, TextAlignment alignment, Color? color = null, bool richText = false)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)component == (Object)null))
			{
				Type type = ((object)component).GetType();
				if (richText)
				{
					type.GetProperty("richText")?.SetValue(component, true, null);
				}
				type.GetProperty("text")?.SetValue(component, value, null);
				if (size.HasValue)
				{
					type.GetProperty("fontSize")?.SetValue(component, size.Value, null);
				}
				PropertyInfo property = type.GetProperty("alignment");
				if (property != null)
				{
					object value2 = Enum.ToObject(property.PropertyType, (int)alignment);
					property.SetValue(component, value2, null);
				}
				if (color.HasValue)
				{
					type.GetProperty("color")?.SetValue(component, color.Value, null);
				}
				ForceMeshUpdate(component);
			}
		}

		private static void ConfigureLayoutChildRect(RectTransform rect, float preferredWidth = -1f, float preferredHeight = -1f, bool flexibleWidth = false)
		{
			//IL_0039: 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_0059: 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)
			LayoutElement val = ((Component)rect).gameObject.AddComponent<LayoutElement>();
			if (preferredWidth > 0f)
			{
				val.preferredWidth = preferredWidth;
			}
			if (preferredHeight > 0f)
			{
				val.preferredHeight = preferredHeight;
			}
			if (flexibleWidth)
			{
				val.flexibleWidth = 1f;
			}
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
		}

		private static void StretchTextRect(Component textComponent)
		{
			//IL_001c: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			if (!((Object)(object)textComponent == (Object)null))
			{
				RectTransform component = textComponent.GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					component.anchorMin = Vector2.zero;
					component.anchorMax = Vector2.one;
					component.pivot = new Vector2(0.5f, 0.5f);
					component.offsetMin = Vector2.zero;
					component.offsetMax = Vector2.zero;
				}
			}
		}

		private static void ForceMeshUpdate(Component textComponent)
		{
			if (!((Object)(object)textComponent == (Object)null))
			{
				Type type = ((object)textComponent).GetType();
				type.GetMethod("ForceMeshUpdate", Type.EmptyTypes)?.Invoke(textComponent, null);
				type.GetMethod("UpdateMeshPadding", Type.EmptyTypes)?.Invoke(textComponent, null);
			}
		}

		private static void CopyTextTemplate(Component component)
		{
			if (!((Object)(object)component == (Object)null) && !((Object)(object)_textTemplate == (Object)null))
			{
				CopyProperty(_textTemplate, component, "font");
				CopyProperty(_textTemplate, component, "fontSharedMaterial");
				CopyProperty(_textTemplate, component, "material");
				CopyProperty(_textTemplate, component, "raycastTarget", false);
			}
		}

		private static void CopyProperty(Component source, Component target, string propertyName, object fallback = null)
		{
			PropertyInfo property = ((object)target).GetType().GetProperty(propertyName);
			if (property == null || !property.CanWrite)
			{
				return;
			}
			try
			{
				PropertyInfo property2 = ((object)source).GetType().GetProperty(propertyName);
				object obj = ((property2 != null && property2.CanRead) ? property2.GetValue(source, null) : fallback);
				if (obj != null || fallback != null)
				{
					property.SetValue(target, obj, null);
				}
			}
			catch
			{
			}
		}

		private static void HandleSearchInput()
		{
			if (_listeningForBattleDashKey)
			{
				HandleBattleDashKeyCapture();
			}
			else if (_listeningForAutoShootKey)
			{
				HandleAutoShootKeyCapture();
			}
			else
			{
				if (!_searchFocused || (Object)(object)_panel == (Object)null || !_panel.activeSelf)
				{
					return;
				}
				if (Input.GetKeyDown((KeyCode)27))
				{
					_searchFocused = false;
					UpdateSearchLabel();
					return;
				}
				string inputString = Input.inputString;
				if (string.IsNullOrEmpty(inputString))
				{
					return;
				}
				bool flag = false;
				string text = inputString;
				for (int i = 0; i < text.Length; i++)
				{
					char c = text[i];
					switch (c)
					{
					case '\b':
						if (_search.Length > 0)
						{
							_search = _search.Substring(0, _search.Length - 1);
							flag = true;
						}
						break;
					case '\n':
					case '\r':
						_searchFocused = false;
						break;
					default:
						if (!char.IsControl(c))
						{
							_search += c;
							flag = true;
						}
						break;
					}
				}
				if (flag)
				{
					UpdateSearchLabel();
					Refresh(resetScroll: true);
				}
			}
		}

		private static void UpdateSearchLabel()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			string value = ((!string.IsNullOrEmpty(_search)) ? (_search + (_searchFocused ? "|" : "")) : (_searchFocused ? "|" : "Search..."));
			SetText(_searchText, value, (float?)17f, TextAlignment.Left, (Color?)new Color(0.86f, 0.88f, 0.9f, 1f), richText: false);
		}

		private static void HandleBattleDashKeyCapture()
		{
			//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_0058: 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_005e: Invalid comparison between Unknown and I4
			//IL_0060: 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 ((Object)(object)_panel == (Object)null || !_panel.activeSelf)
			{
				_listeningForBattleDashKey = false;
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				_listeningForBattleDashKey = false;
				UpdateBattleDashKeyButtonLabel();
				return;
			}
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				if ((int)value != 0 && (int)value != 27 && Input.GetKeyDown(value))
				{
					AimExclusionStore.SetBattleDashToggleKey(value);
					_listeningForBattleDashKey = false;
					UpdateBattleDashKeyButtonLabel();
					break;
				}
			}
		}

		private static void HandleAutoShootKeyCapture()
		{
			//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_0058: 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_005e: Invalid comparison between Unknown and I4
			//IL_0060: 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 ((Object)(object)_panel == (Object)null || !_panel.activeSelf)
			{
				_listeningForAutoShootKey = false;
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				_listeningForAutoShootKey = false;
				UpdateAutoShootKeyButtonLabel();
				return;
			}
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				if ((int)value != 0 && (int)value != 27 && Input.GetKeyDown(value))
				{
					AimExclusionStore.SetAutoShootToggleKey(value);
					_listeningForAutoShootKey = false;
					UpdateAutoShootKeyButtonLabel();
					break;
				}
			}
		}
	}
	internal static class AimExclusionStore
	{
		private class AimExclusionFile
		{
			public int version;

			public int battleDashToggleKey = 306;

			public int autoShootToggleKey = 118;

			public List<UnitEntry> units = new List<UnitEntry>();
		}

		internal class UnitEntry
		{
			public string guid;

			public string name;

			public string source;

			public int modId;

			public int workshopModId;

			public bool? isRanged;

			public bool excluded;

			public bool rangeGateEnabled = true;

			public bool volleySpreadEnabled;

			public bool meleeDashEnabled;

			public bool verticalAimEnabled = true;

			[JsonIgnore]
			public Sprite iconSprite;

			[JsonIgnore]
			public Texture iconTexture;

			[JsonIgnore]
			public object iconEntity;
		}

		internal const string FileName = "FreeAim.AimExclusions.json";

		private static readonly HashSet<string> ExcludedUnits = new HashSet<string>();

		private static readonly HashSet<string> RangeGateDisabled = new HashSet<string>();

		private const int SaveFormatVersion = 13;

		internal const KeyCode DefaultBattleDashToggleKey = 306;

		internal const KeyCode DefaultAutoShootToggleKey = 118;

		private static KeyCode _battleDashToggleKey = (KeyCode)306;

		private static KeyCode _autoShootToggleKey = (KeyCode)118;

		internal const string BuiltInSource = "Built-in";

		internal const string CustomSource = "Custom";

		private static readonly Dictionary<string, UnitEntry> UnitEntries = new Dictionary<string, UnitEntry>();

		private static int _lastUnitDiscoveryCount;

		private static int _builtInCount;

		private static int _customCount;

		private static bool _pendingDefaultSeed;

		private static bool _discoveryComplete;

		private static bool _pendingVolleySpreadSeed;

		private static bool _pendingMeleeDashSeed;

		private static bool _pendingVerticalAimSeed;

		private static readonly HashSet<string> DefaultExcludedUnitNames = new HashSet<string>
		{
			"UNIT_ASIA_HWACHA", "UNIT_FANTASYEVIL_MECHANIC", "UNIT_FANTASYEVIL_STORMPRIEST", "UNIT_FANTASYGOOD_ORBCASTER", "UNIT_FANTASYGOOD_TIMENINJA", "UNIT_FANTASYGOOD_TIMENINJATRANSFORMED", "UNIT_FARMER_SCARECROW", "UNIT_HALLOWEEN_SPOOKYCATAPULT", "UNIT_HALLOWEEN_SWORDCASTER", "UNIT_LEGACY_LEG_WIZARD",
			"UNIT_MEDIEVAL_CATAPULT", "UNIT_MEDIEVAL_PRIEST", "UNIT_PIRATE_CANNON", "UNIT_RENAISSANCE_DAVINCITANK", "UNIT_SECRET_BANSHEE", "UNIT_SECRET_BOMBCANNON", "UNIT_SECRET_INFERNAL_WHIP", "UNIT_SUBUNITS_DAVINCI", "UNIT_WESTERN_GUNSLINGER"
		};

		private static string FilePath => Path.Combine(Paths.ConfigPath, "FreeAim.AimExclusions.json");

		internal static IReadOnlyCollection<UnitEntry> Units => UnitEntries.Values;

		internal static string DiscoverySummary => $"{_lastUnitDiscoveryCount} units ({_builtInCount} built-in, {_customCount} custom)";

		internal static void Load()
		{
			//IL_00a1: 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)
			ExcludedUnits.Clear();
			RangeGateDisabled.Clear();
			UnitEntries.Clear();
			try
			{
				if (!File.Exists(FilePath))
				{
					_pendingDefaultSeed = true;
					return;
				}
				AimExclusionFile aimExclusionFile = JsonConvert.DeserializeObject<AimExclusionFile>(File.ReadAllText(FilePath)) ?? new AimExclusionFile();
				bool flag = aimExclusionFile.version < 13;
				if (aimExclusionFile.version < 9)
				{
					_pendingVolleySpreadSeed = true;
				}
				if (aimExclusionFile.version < 10)
				{
					_pendingMeleeDashSeed = true;
				}
				if (aimExclusionFile.version < 13)
				{
					_pendingVerticalAimSeed = true;
				}
				if (aimExclusionFile.version >= 11 && aimExclusionFile.battleDashToggleKey != 0)
				{
					_battleDashToggleKey = (KeyCode)aimExclusionFile.battleDashToggleKey;
				}
				if (aimExclusionFile.version >= 12 && aimExclusionFile.autoShootToggleKey != 0)
				{
					_autoShootToggleKey = (KeyCode)aimExclusionFile.autoShootToggleKey;
				}
				foreach (UnitEntry item in aimExclusionFile.units ?? new List<UnitEntry>())
				{
					if (!string.IsNullOrWhiteSpace(item.guid))
					{
						if (flag && aimExclusionFile.version < 8)
						{
							item.rangeGateEnabled = true;
							item.source = null;
						}
						UnitEntries[item.guid] = item;
						if (item.excluded)
						{
							ExcludedUnits.Add(item.guid);
						}
						if (!item.rangeGateEnabled)
						{
							RangeGateDisabled.Add(item.guid);
						}
					}
				}
				if (flag)
				{
					_discoveryComplete = false;
				}
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Aim exclusions: failed to load FreeAim.AimExclusions.json: " + ex.Message);
			}
		}

		internal static void Save()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected I4, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected I4, but got Unknown
			try
			{
				Directory.CreateDirectory(Paths.ConfigPath);
				AimExclusionFile aimExclusionFile = new AimExclusionFile
				{
					version = 13,
					battleDashToggleKey = (int)_battleDashToggleKey,
					autoShootToggleKey = (int)_autoShootToggleKey,
					units = UnitEntries.Values.OrderBy((UnitEntry u) => u.name).ToList()
				};
				File.WriteAllText(FilePath, JsonConvert.SerializeObject((object)aimExclusionFile, (Formatting)1));
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Aim exclusions: failed to save FreeAim.AimExclusions.json: " + ex.Message);
			}
		}

		internal static void EnsureDiscovered(bool force = false)
		{
			if (!File.Exists(FilePath))
			{
				_pendingDefaultSeed = true;
			}
			if (!force && _discoveryComplete)
			{
				ApplyDefaultSeedIfNeeded();
				return;
			}
			RefreshDiscoveredContent();
			_discoveryComplete = true;
			ApplyDefaultSeedIfNeeded();
		}

		private static void ApplyDefaultSeedIfNeeded()
		{
			if (_pendingDefaultSeed)
			{
				int num = 0;
				try
				{
					num = ApplyDefaultExclusions();
				}
				catch (Exception ex)
				{
					Plugin.LogWarning("Aim exclusions: failed to apply default exclusions: " + ex.Message);
				}
				_pendingDefaultSeed = false;
				Save();
				Plugin.LogInfo($"Aim exclusions: default exclusions seeded ({num} units)");
			}
		}

		internal static void HandleUnitRemoved(DatabaseID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string text = Key(id);
			if (!string.IsNullOrEmpty(text) && UnitEntries.Remove(text))
			{
				ExcludedUnits.Remove(text);
				RangeGateDisabled.Remove(text);
				_lastUnitDiscoveryCount = UnitEntries.Count;
				_builtInCount = UnitEntries.Values.Count((UnitEntry u) => u.source != "Custom");
				_customCount = UnitEntries.Values.Count((UnitEntry u) => u.source == "Custom");
				Save();
				Plugin.LogInfo("Aim exclusions: removed deleted unit (" + text + ")");
				AimExclusionMenu.NotifyContentChanged();
			}
		}

		internal static void RemoveUserUnitBlueprint_Postfix(DatabaseID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			HandleUnitRemoved(id);
		}

		internal static void RefreshDiscoveredContent()
		{
			try
			{
				int count = UnitEntries.Count;
				ContentDatabase val = ContentDatabase.Instance();
				if (val == null)
				{
					return;
				}
				IEnumerable<UnitBlueprint> allUnitBlueprints = val.GetAllUnitBlueprints();
				if (allUnitBlueprints == null)
				{
					return;
				}
				HashSet<string> hashSet = new HashSet<string>();
				foreach (UnitBlueprint item in allUnitBlueprints)
				{
					TryRegisterUnit(item, hashSet);
				}
				if (hashSet.Count > 0)
				{
					int num = PruneStaleEntries(hashSet);
					if (num > 0)
					{
						Plugin.LogInfo($"Aim exclusions: pruned {num} removed unit(s)");
					}
				}
				_lastUnitDiscoveryCount = UnitEntries.Count;
				_builtInCount = UnitEntries.Values.Count((UnitEntry u) => u.source != "Custom");
				_customCount = UnitEntries.Values.Count((UnitEntry u) => u.source == "Custom");
				if (_lastUnitDiscoveryCount != count || !_discoveryComplete)
				{
					Plugin.LogInfo("Aim exclusions: discovered " + DiscoverySummary);
				}
				if (_pendingVolleySpreadSeed)
				{
					_pendingVolleySpreadSeed = false;
					Plugin.LogInfo("Aim exclusions: volley spread defaults seeded for all units");
				}
				if (_pendingMeleeDashSeed)
				{
					_pendingMeleeDashSeed = false;
					Plugin.LogInfo("Aim exclusions: melee dash defaults seeded for all units");
				}
				if (_pendingVerticalAimSeed)
				{
					_pendingVerticalAimSeed = false;
					Plugin.LogInfo("Aim exclusions: vertical aim defaults seeded for all units");
				}
				Save();
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Aim exclusions: failed to discover units: " + ex.Message);
			}
		}

		private static int ApplyDefaultExclusions()
		{
			int num = 0;
			foreach (UnitEntry item in UnitEntries.Values.ToList())
			{
				if (!string.IsNullOrWhiteSpace(item.name) && DefaultExcludedUnitNames.Contains(item.name))
				{
					if (ExcludedUnits.Add(item.guid))
					{
						num++;
					}
					item.excluded = true;
				}
			}
			return num;
		}

		internal static UnitEntry RegisterUnit(UnitBlueprint blueprint)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (((blueprint != null) ? blueprint.Entity : null) == null)
			{
				return null;
			}
			string text = Key(blueprint.Entity.GUID);
			UnitEntry value;
			bool num = !UnitEntries.TryGetValue(text, out value);
			if (num)
			{
				value = new UnitEntry
				{
					guid = text
				};
				UnitEntries[text] = value;
			}
			value.name = blueprint.Entity.Name ?? blueprint.Name ?? text;
			value.modId = blueprint.Entity.GUID.m_modID;
			value.workshopModId = blueprint.ModID;
			value.source = ClassifyUnitSource(blueprint);
			value.isRanged = ClassifyIsRanged(blueprint);
			value.excluded = ExcludedUnits.Contains(text);
			value.rangeGateEnabled = ShouldApplyRangeGate(text);
			if (num || _pendingVolleySpreadSeed)
			{
				value.volleySpreadEnabled = ClassifyDefaultVolleySpread(blueprint);
			}
			if (num || _pendingMeleeDashSeed)
			{
				value.meleeDashEnabled = ClassifyDefaultMeleeDash(blueprint);
			}
			if (num || _pendingVerticalAimSeed)
			{
				value.verticalAimEnabled = ClassifyDefaultVerticalAim(blueprint);
			}
			value.iconEntity = blueprint.Entity;
			return value;
		}

		internal static bool ClassifyDefaultVolleySpread(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return false;
			}
			if (GetRangeWeaponProjectileCount(blueprint.RightWeapon) <= 1)
			{
				return GetRangeWeaponProjectileCount(blueprint.LeftWeapon) > 1;
			}
			return true;
		}

		internal static bool ClassifyDefaultMeleeDash(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return false;
			}
			if (!HasWeaponComponent<WeaponForceAnimation>(blueprint.RightWeapon))
			{
				return HasWeaponComponent<WeaponForceAnimation>(blueprint.LeftWeapon);
			}
			return true;
		}

		internal static bool ClassifyDefaultVerticalAim(UnitBlueprint blueprint)
		{
			return true;
		}

		internal static bool IsMeleeDashCapable(Unit unit)
		{
			return ClassifyDefaultMeleeDash(unit?.unitBlueprint);
		}

		internal static bool IsMeleeDashCapable(DataHandler data)
		{
			return IsMeleeDashCapable(data?.unit);
		}

		internal static bool HasRuntimeMeleeWeapon(Unit unit)
		{
			if ((Object)(object)unit == (Object)null)
			{
				return false;
			}
			WeaponHandler componentInChildren = ((Component)unit).GetComponentInChildren<WeaponHandler>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return false;
			}
			if (!(componentInChildren.leftWeapon is MeleeWeapon))
			{
				return componentInChildren.rightWeapon is MeleeWeapon;
			}
			return true;
		}

		internal static bool HasBlueprintMeleeWeapon(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return false;
			}
			if (ClassifyIsRanged(blueprint).GetValueOrDefault())
			{
				return false;
			}
			if (!HasWeaponComponent<MeleeWeapon>(blueprint.RightWeapon))
			{
				return HasWeaponComponent<MeleeWeapon>(blueprint.LeftWeapon);
			}
			return true;
		}

		internal static bool HasRuntimeRangeWeapon(Unit unit)
		{
			if ((Object)(object)unit == (Object)null)
			{
				return false;
			}
			WeaponHandler componentInChildren = ((Component)unit).GetComponentInChildren<WeaponHandler>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return false;
			}
			if (!(componentInChildren.leftWeapon is RangeWeapon))
			{
				return componentInChildren.rightWeapon is RangeWeapon;
			}
			return true;
		}

		internal static bool HasBlueprintRangeWeapon(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return false;
			}
			if (ClassifyIsRanged(blueprint) == false)
			{
				return false;
			}
			if (!HasWeaponComponent<RangeWeapon>(blueprint.RightWeapon))
			{
				return HasWeaponComponent<RangeWeapon>(blueprint.LeftWeapon);
			}
			return true;
		}

		internal static bool ShouldShowBattleDashToggle(DataHandler data)
		{
			Unit val = data?.unit;
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (ClassifyIsRanged(val.unitBlueprint).GetValueOrDefault())
			{
				return false;
			}
			if (!HasRuntimeMeleeWeapon(val))
			{
				return HasBlueprintMeleeWeapon(val.unitBlueprint);
			}
			return true;
		}

		internal static bool ShouldShowAutoShootToggle(DataHandler data)
		{
			Unit val = data?.unit;
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (ClassifyIsRanged(val.unitBlueprint) == false)
			{
				return false;
			}
			return PossessionHoldAttack.UnitQualifiesForAutoShoot(val);
		}

		internal static KeyCode GetBattleDashToggleKey()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return _battleDashToggleKey;
		}

		internal static void SetBattleDashToggleKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key != 0)
			{
				_battleDashToggleKey = key;
				Save();
			}
		}

		internal static KeyCode GetAutoShootToggleKey()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return _autoShootToggleKey;
		}

		internal static void SetAutoShootToggleKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key != 0)
			{
				_autoShootToggleKey = key;
				Save();
			}
		}

		internal static string FormatKeyName(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected I4, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Invalid comparison between Unknown and I4
			//IL_0091: 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_00b5: Expected I4, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Invalid comparison between Unknown and I4
			//IL_0027: 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_0054: Expected I4, but got Unknown
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Invalid comparison between Unknown and I4
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Invalid comparison between Unknown and I4
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Invalid comparison between Unknown and I4
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Invalid comparison between Unknown and I4
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Invalid comparison between Unknown and I4
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Expected I4, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Invalid comparison between Unknown and I4
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: 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_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected I4, but got Unknown
			if ((int)key <= 47)
			{
				if ((int)key <= 27)
				{
					if ((int)key == 13)
					{
						return "Enter";
					}
					if ((int)key == 27)
					{
						return "Esc";
					}
				}
				else
				{
					if ((int)key == 32)
					{
						return "Space";
					}
					switch (key - 39)
					{
					case 6:
						return "-";
					case 0:
						return "'";
					case 5:
						return ",";
					case 7:
						return ".";
					case 8:
						return "/";
					}
				}
			}
			else if ((int)key <= 61)
			{
				if ((int)key == 59)
				{
					return ";";
				}
				if ((int)key == 61)
				{
					return "=";
				}
			}
			else
			{
				switch (key - 91)
				{
				default:
					switch (key - 303)
					{
					case 2:
					case 3:
						return "Ctrl";
					case 0:
					case 1:
						return "Shift";
					case 4:
					case 5:
						return "Alt";
					}
					break;
				case 5:
					return "`";
				case 0:
					return "[";
				case 2:
					return "]";
				case 1:
					return "\\";
				case 3:
				case 4:
					break;
				}
			}
			if ((int)key >= 48 && (int)key <= 57)
			{
				return ((char)(48 + (key - 48))).ToString();
			}
			if ((int)key >= 256 && (int)key <= 265)
			{
				return "Num " + (key - 256);
			}
			if ((int)key >= 97 && (int)key <= 122)
			{
				return ((char)(65 + (key - 97))).ToString();
			}
			if ((int)key >= 282 && (int)key <= 293)
			{
				return "F" + (key - 282 + 1);
			}
			return ((object)(KeyCode)(ref key)).ToString();
		}

		internal static bool WasBattleDashToggleKeyPressed()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return WasToggleKeyPressed(_battleDashToggleKey);
		}

		internal static bool WasAutoShootToggleKeyPressed()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return WasToggleKeyPressed(_autoShootToggleKey);
		}

		private static bool WasToggleKeyPressed(KeyCode key)
		{
			//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_0010: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Invalid comparison between Unknown and I4
			if (Input.GetKeyDown(key))
			{
				return true;
			}
			if ((int)key == 306 || (int)key == 305)
			{
				if (!Input.GetKeyDown((KeyCode)306))
				{
					return Input.GetKeyDown((KeyCode)305);
				}
				return true;
			}
			if ((int)key == 304 || (int)key == 303)
			{
				if (!Input.GetKeyDown((KeyCode)304))
				{
					return Input.GetKeyDown((KeyCode)303);
				}
				return true;
			}
			if ((int)key == 308 || (int)key == 307)
			{
				if (!Input.GetKeyDown((KeyCode)308))
				{
					return Input.GetKeyDown((KeyCode)307);
				}
				return true;
			}
			return false;
		}

		private static int GetRangeWeaponProjectileCount(GameObject weaponObject)
		{
			RangeWeapon weaponComponent = GetWeaponComponent<RangeWeapon>(weaponObject);
			if (!((Object)(object)weaponComponent != (Object)null))
			{
				return 1;
			}
			return weaponComponent.numberOfObjects;
		}

		private static T GetWeaponComponent<T>(GameObject weaponObject) where T : Component
		{
			if ((Object)(object)weaponObject == (Object)null)
			{
				return default(T);
			}
			try
			{
				return weaponObject.GetComponent<T>() ?? weaponObject.GetComponentInChildren<T>(true);
			}
			catch
			{
				return default(T);
			}
		}

		internal static string ClassifyUnitSource(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return "Built-in";
			}
			if (blueprint.IsCustomUnit && !blueprint.IsModUnit)
			{
				return "Custom";
			}
			return "Built-in";
		}

		internal static bool IsBuiltInSource(string source)
		{
			return source != "Custom";
		}

		internal static bool? ClassifyIsRanged(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return null;
			}
			bool flag = HasWeaponComponent<MeleeWeapon>(blueprint.RightWeapon) || HasWeaponComponent<MeleeWeapon>(blueprint.LeftWeapon);
			bool flag2 = HasWeaponComponent<RangeWeapon>(blueprint.RightWeapon) || HasWeaponComponent<RangeWeapon>(blueprint.LeftWeapon);
			if (flag2 && flag)
			{
				return null;
			}
			if (flag2)
			{
				return true;
			}
			if (flag)
			{
				return false;
			}
			return null;
		}

		internal static string FormatCombatTag(bool? isRanged)
		{
			if (isRanged.GetValueOrDefault())
			{
				return "Ranged";
			}
			if (isRanged == false)
			{
				return "Melee";
			}
			return "Mixed";
		}

		private static bool HasWeaponComponent<T>(GameObject weaponObject) where T : Component
		{
			return (Object)(object)GetWeaponComponent<T>(weaponObject) != (Object)null;
		}

		internal static void EnsureEntryIcon(UnitEntry entry)
		{
			if (entry != null && !((Object)(object)entry.iconSprite != (Object)null))
			{
				entry.iconSprite = AimExclusionIcons.TryGetLoadedSprite(entry.iconEntity);
				entry.iconTexture = (Texture)(object)(((Object)(object)entry.iconSprite != (Object)null) ? entry.iconSprite.texture : null);
			}
		}

		internal static bool IsUnitExcluded(Unit unit)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			DatabaseID? id;
			if (unit == null)
			{
				id = null;
			}
			else
			{
				UnitBlueprint unitBlueprint = unit.unitBlueprint;
				if (unitBlueprint == null)
				{
					id = null;
				}
				else
				{
					DatabaseEntity entity = unitBlueprint.Entity;
					id = ((entity != null) ? new DatabaseID?(entity.GUID) : null);
				}
			}
			string text = Key(id);
			if (!string.IsNullOrEmpty(text))
			{
				return ExcludedUnits.Contains(text);
			}
			return false;
		}

		internal static bool IsUnitExcluded(DataHandler data)
		{
			return IsUnitExcluded(data?.unit);
		}

		internal static void SetUnitExcluded(UnitEntry entry, bool excluded)
		{
			if (entry != null && !string.IsNullOrWhiteSpace(entry.guid))
			{
				entry.excluded = excluded;
				UnitEntries[entry.guid] = entry;
				if (excluded)
				{
					ExcludedUnits.Add(entry.guid);
				}
				else
				{
					ExcludedUnits.Remove(entry.guid);
				}
				Save();
			}
		}

		internal static void SetUnitRangeGate(UnitEntry entry, bool enabled)
		{
			if (entry != null && !string.IsNullOrWhiteSpace(entry.guid))
			{
				entry.rangeGateEnabled = enabled;
				UnitEntries[entry.guid] = entry;
				if (enabled)
				{
					RangeGateDisabled.Remove(entry.guid);
				}
				else
				{
					RangeGateDisabled.Add(entry.guid);
				}
				Save();
			}
		}

		internal static void SetUnitVolleySpread(UnitEntry entry, bool enabled)
		{
			if (entry != null && !string.IsNullOrWhiteSpace(entry.guid))
			{
				entry.volleySpreadEnabled = enabled;
				UnitEntries[entry.guid] = entry;
				Save();
			}
		}

		internal static void SetUnitMeleeDash(UnitEntry entry, bool enabled)
		{
			if (entry != null && !string.IsNullOrWhiteSpace(entry.guid))
			{
				entry.meleeDashEnabled = enabled;
				UnitEntries[entry.guid] = entry;
				Save();
			}
		}

		internal static void SetUnitVerticalAim(UnitEntry entry, bool enabled)
		{
			if (entry != null && !string.IsNullOrWhiteSpace(entry.guid))
			{
				entry.verticalAimEnabled = enabled;
				UnitEntries[entry.guid] = entry;
				Save();
			}
		}

		internal static void ClearAll()
		{
			SetAllExcluded(excluded: false);
			SetAllRangeGate(enabled: true);
			ApplyDefaultVolleySpreadForAll();
			ApplyDefaultMeleeDashForAll();
			ApplyDefaultVerticalAimForAll();
		}

		internal static void ResetToDefaults()
		{
			ExcludedUnits.Clear();
			RangeGateDisabled.Clear();
			foreach (UnitEntry value in UnitEntries.Values)
			{
				value.excluded = false;
				value.rangeGateEnabled = true;
			}
			ApplyDefaultVolleySpreadForAll();
			ApplyDefaultMeleeDashForAll();
			ApplyDefaultVerticalAimForAll();
			int num = ApplyDefaultExclusions();
			Save();
			Plugin.LogInfo($"Aim exclusions: reset to defaults ({num} units excluded)");
		}

		internal static void SetAllExcluded(bool excluded)
		{
			foreach (UnitEntry value in UnitEntries.Values)
			{
				if (!string.IsNullOrWhiteSpace(value.guid))
				{
					value.excluded = excluded;
					if (excluded)
					{
						ExcludedUnits.Add(value.guid);
					}
					else
					{
						ExcludedUnits.Remove(value.guid);
					}
				}
			}
			Save();
		}

		internal static void SetAllRangeGate(bool enabled)
		{
			foreach (UnitEntry value in UnitEntries.Values)
			{
				if (!string.IsNullOrWhiteSpace(value.guid))
				{
					value.rangeGateEnabled = enabled;
					if (enabled)
					{
						RangeGateDisabled.Remove(value.guid);
					}
					else
					{
						RangeGateDisabled.Add(value.guid);
					}
				}
			}
			Save();
		}

		internal static void SetAllVolleySpread(bool enabled)
		{
			foreach (UnitEntry value in UnitEntries.Values)
			{
				if (!string.IsNullOrWhiteSpace(value.guid))
				{
					value.volleySpreadEnabled = enabled;
				}
			}
			Save();
		}

		internal static void SetAllMeleeDash(bool enabled)
		{
			foreach (UnitEntry value in UnitEntries.Values)
			{
				if (!string.IsNullOrWhiteSpace(value.guid))
				{
					value.meleeDashEnabled = enabled;
				}
			}
			Save();
		}

		internal static void SetAllVerticalAim(bool enabled)
		{
			foreach (UnitEntry value in UnitEntries.Values)
			{
				if (!string.IsNullOrWhiteSpace(value.guid))
				{
					value.verticalAimEnabled = enabled;
				}
			}
			Save();
		}

		private static void ApplyDefaultVolleySpreadForAll()
		{
			Dictionary<string, UnitBlueprint> dictionary = BuildBlueprintLookup();
			foreach (UnitEntry value2 in UnitEntries.Values)
			{
				if (!string.IsNullOrWhiteSpace(value2.guid))
				{
					value2.volleySpreadEnabled = dictionary.TryGetValue(value2.guid, out var value) && ClassifyDefaultVolleySpread(value);
				}
			}
		}

		private static void ApplyDefaultMeleeDashForAll()
		{
			Dictionary<string, UnitBlueprint> dictionary = BuildBlueprintLookup();
			foreach (UnitEntry value2 in UnitEntries.Values)
			{
				if (!string.IsNullOrWhiteSpace(value2.guid))
				{
					value2.meleeDashEnabled = dictionary.TryGetValue(value2.guid, out var value) && ClassifyDefaultMeleeDash(value);
				}
			}
		}

		private static void ApplyDefaultVerticalAimForAll()
		{
			foreach (UnitEntry value in UnitEntries.Values)
			{
				if (!string.IsNullOrWhiteSpace(value.guid))
				{
					value.verticalAimEnabled = true;
				}
			}
		}

		private static Dictionary<string, UnitBlueprint> BuildBlueprintLookup()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, UnitBlueprint> dictionary = new Dictionary<string, UnitBlueprint>();
			ContentDatabase val = ContentDatabase.Instance();
			if (val == null)
			{
				return dictionary;
			}
			foreach (UnitBlueprint item in val.GetAllUnitBlueprints() ?? Enumerable.Empty<UnitBlueprint>())
			{
				DatabaseEntity entity = item.Entity;
				string text = Key((entity != null) ? new DatabaseID?(entity.GUID) : null);
				if (!string.IsNullOrEmpty(text))
				{
					dictionary[text] = item;
				}
			}
			return dictionary;
		}

		internal static bool ShouldUseVolleySpread(string unitGuid)
		{
			if (string.IsNullOrEmpty(unitGuid))
			{
				return false;
			}
			if (UnitEntries.TryGetValue(unitGuid, out var value))
			{
				return value.volleySpreadEnabled;
			}
			return false;
		}

		internal static bool ShouldUseVolleySpread(Unit unit)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			DatabaseID? id;
			if (unit == null)
			{
				id = null;
			}
			else
			{
				UnitBlueprint unitBlueprint = unit.unitBlueprint;
				if (unitBlueprint == null)
				{
					id = null;
				}
				else
				{
					DatabaseEntity entity = unitBlueprint.Entity;
					id = ((entity != null) ? new DatabaseID?(entity.GUID) : null);
				}
			}
			return ShouldUseVolleySpread(Key(id));
		}

		internal static bool ShouldUseVolleySpread(DataHandler data)
		{
			return ShouldUseVolleySpread(data?.unit);
		}

		internal static bool ShouldUseMeleeDash(string unitGuid)
		{
			if (string.IsNullOrEmpty(unitGuid))
			{
				return false;
			}
			if (UnitEntries.TryGetValue(unitGuid, out var value))
			{
				return value.meleeDashEnabled;
			}
			return false;
		}

		internal static bool ShouldUseMeleeDash(Unit unit)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			DatabaseID? id;
			if (unit == null)
			{
				id = null;
			}
			else
			{
				UnitBlueprint unitBlueprint = unit.unitBlueprint;
				if (unitBlueprint == null)
				{
					id = null;
				}
				else
				{
					DatabaseEntity entity = unitBlueprint.Entity;
					id = ((entity != null) ? new DatabaseID?(entity.GUID) : null);
				}
			}
			return ShouldUseMeleeDash(Key(id));
		}

		internal static bool ShouldUseMeleeDash(DataHandler data)
		{
			return ShouldUseMeleeDash(data?.unit);
		}

		internal static bool ShouldUseVerticalAim(string unitGuid)
		{
			if (string.IsNullOrEmpty(unitGuid))
			{
				return true;
			}
			if (UnitEntries.TryGetValue(unitGuid, out var value))
			{
				return value.verticalAimEnabled;
			}
			return true;
		}

		internal static bool ShouldUseVerticalAim(Unit unit)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			DatabaseID? id;
			if (unit == null)
			{
				id = null;
			}
			else
			{
				UnitBlueprint unitBlueprint = unit.unitBlueprint;
				if (unitBlueprint == null)
				{
					id = null;
				}
				else
				{
					DatabaseEntity entity = unitBlueprint.Entity;
					id = ((entity != null) ? new DatabaseID?(entity.GUID) : null);
				}
			}
			return ShouldUseVerticalAim(Key(id));
		}

		internal static bool ShouldUseVerticalAim(DataHandler data)
		{
			return ShouldUseVerticalAim(data?.unit);
		}

		internal static bool ShouldApplyModWeaponHold(DataHandler data)
		{
			if (ShouldUseCrosshairAim(data))
			{
				return ShouldUseVerticalAim(data);
			}
			return false;
		}

		internal static bool ShouldUseCrosshairAim(string unitGuid)
		{
			if (string.IsNullOrEmpty(unitGuid))
			{
				return true;
			}
			return !ExcludedUnits.Contains(unitGuid);
		}

		internal static bool ShouldUseCrosshairAim(Unit unit)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			DatabaseID? id;
			if (unit == null)
			{
				id = null;
			}
			else
			{
				UnitBlueprint unitBlueprint = unit.unitBlueprint;
				if (unitBlueprint == null)
				{
					id = null;
				}
				else
				{
					DatabaseEntity entity = unitBlueprint.Entity;
					id = ((entity != null) ? new DatabaseID?(entity.GUID) : null);
				}
			}
			return ShouldUseCrosshairAim(Key(id));
		}

		internal static bool ShouldUseCrosshairAim(DataHandler data)
		{
			return ShouldUseCrosshairAim(data?.unit);
		}

		internal static bool ShouldApplyRangeGate(string unitGuid)
		{
			if (string.IsNullOrEmpty(unitGuid))
			{
				return true;
			}
			return !RangeGateDisabled.Contains(unitGuid);
		}

		internal static bool ShouldApplyRangeGate(Unit unit)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			DatabaseID? id;
			if (unit == null)
			{
				id = null;
			}
			else
			{
				UnitBlueprint unitBlueprint = unit.unitBlueprint;
				if (unitBlueprint == null)
				{
					id = null;
				}
				else
				{
					DatabaseEntity entity = unitBlueprint.Entity;
					id = ((entity != null) ? new DatabaseID?(entity.GUID) : null);
				}
			}
			return ShouldApplyRangeGate(Key(id));
		}

		internal static bool ShouldApplyRangeGate(DataHandler data)
		{
			return ShouldApplyRangeGate(data?.unit);
		}

		internal static bool ShouldThrowAtCrosshair(DataHandler data)
		{
			return ShouldUseCrosshairAim(data);
		}

		private static int PruneStaleEntries(HashSet<string> seenGuids)
		{
			if (seenGuids == null)
			{
				return 0;
			}
			int num = 0;
			foreach (string item in UnitEntries.Keys.ToList())
			{
				if (!seenGuids.Contains(item))
				{
					UnitEntries.Remove(item);
					ExcludedUnits.Remove(item);
					RangeGateDisabled.Remove(item);
					num++;
				}
			}
			return num;
		}

		private static void TryRegisterUnit(UnitBlueprint unit, HashSet<string> seen)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)unit == (Object)null)
			{
				return;
			}
			DatabaseEntity entity = unit.Entity;
			string text = Key((entity != null) ? new DatabaseID?(entity.GUID) : null);
			if (string.IsNullOrEmpty(text) || !seen.Add(text))
			{
				return;
			}
			try
			{
				RegisterUnit(unit);
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Aim exclusions: failed to register unit " + ((Object)unit).name + ": " + ex.Message);
			}
		}

		internal static string Key(DatabaseID? id)
		{
			//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: 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)
			if (!id.HasValue)
			{
				return null;
			}
			DatabaseID value = id.Value;
			return $"{value.m_modID}:{value.m_ID}";
		}
	}
	internal static class BattleMeleeDashStore
	{
		private static readonly HashSet<int> DisabledInstanceIds = new HashSet<int>();

		internal static void Clear()
		{
			DisabledInstanceIds.Clear();
		}

		internal static bool IsDisabled(DataHandler data)
		{
			if ((Object)(object)data == (Object)null)
			{
				return false;
			}
			return DisabledInstanceIds.Contains(((Object)((Component)data).transform.root).GetInstanceID());
		}

		internal static void Toggle(DataHandler data)
		{
			if (!((Object)(object)data == (Object)null))
			{
				int instanceID = ((Object)((Component)data).transform.root).GetInstanceID();
				if (DisabledInstanceIds.Contains(instanceID))
				{
					DisabledInstanceIds.Remove(instanceID);
				}
				else
				{
					DisabledInstanceIds.Add(instanceID);
				}
			}
		}

		internal static bool IsEnabled(DataHandler data)
		{
			return !IsDisabled(data);
		}
	}
	internal static class BattleStateHelper
	{
		private static int _checkFrame = -1;

		private static bool _cachedBattleActive;

		internal static bool IsBattleActive()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			if (Time.frameCount == _checkFrame)
			{
				return _cachedBattleActive;
			}
			_checkFrame = Time.frameCount;
			GameStateManager service = ServiceLocator.GetService<GameStateManager>();
			_cachedBattleActive = service != null && (int)service.GameState == 1;
			return _cachedBattleActive;
		}

		internal static void InvalidateCache()
		{
			_checkFrame = -1;
		}
	}
	internal static class FirstPersonFreeAimConfig
	{
		internal static bool Enabled = true;

		internal const float TorqueMultiplier = 1.75f;

		internal const bool BallisticAim = true;

		internal const float BallisticAimMaxDistance = 0f;

		internal const float PossessionCrosshairMapDistance = 500f;

		internal const float BallisticMinSpeedScale = 0.4f;

		internal const float BallisticMaxSpeedScale = 2.75f;

		internal const bool BallisticAimPreserveSpread = true;

		internal const bool BallisticAimRespectSpecialWeapons = true;

		internal const bool PossessionAttackRangeGate = true;

		internal const float PossessionAttackRangeMultiplier = 1.25f;

		internal const float PossessionAbilityTargetConeDegrees = 35f;

		internal const float PossessionUnitQueryInterval = 0.15f;

		internal const int PossessionRaycastMaxUnits = 24;

		internal const float PossessionRaycastAssistDegrees = 4f;

		internal const float PossessionRaycastAssistMaxRadius = 2f;

		internal const bool PredictiveAim = true;

		internal const float PredictiveAimConeDegrees = 5f;

		internal const float PredictiveAimMaxDistance = 0f;

		internal const float PredictiveAimLeadScale = 1f;

		internal const int PredictiveAimIterations = 4;

		internal const float PredictiveAimMinSpeed = 8f;

		internal const float AimReferenceSmoothTime = 0.15f;

		internal const bool SmoothPossessionCamera = true;

		internal const float PossessionCameraSmoothTime = 0.14f;

		internal const float PossessionCameraEyeHeight = 0.42f;

		internal const float PossessionCameraForwardOffset = 0.06f;

		internal const bool PossessionZoomEnabled = true;

		internal const PossessionZoomMode PossessionZoomMode = PossessionZoomMode.ScrollWheel;

		internal const float PossessionZoomMaxMultiplier = 3f;

		internal const float PossessionZoomScrollStep = 0.35f;

		internal const float PossessionZoomSmoothness = 12f;

		internal const float PossessionZoomSensitivityScale = 1f;

		internal static void Bind(ConfigFile config)
		{
			Enabled = config.Bind<bool>("Possession.FirstPerson", "FreeAim", true, "Enable possession aiming changes (crosshair aim, ballistic correction, range gate, zoom). Set false for vanilla possession behavior.").Value;
		}
	}
	internal static class FirstPersonFreeAimPatches
	{
		private static readonly FieldInfo CamField = AccessTools.Field(typeof(PlayerHolding), "cam");

		private static readonly FieldInfo FollowWeaponTargetField = AccessTools.Field(typeof(PlayerHolding), "followWeaponTarget");

		private static readonly FieldInfo TargetForwardField = AccessTools.Field(typeof(PlayerHolding), "targetForward");

		private static readonly FieldInfo TargetUpField = AccessTools.Field(typeof(PlayerHolding), "targetUp");

		private static readonly FieldInfo HoldingTorqueField = AccessTools.Field(typeof(PlayerHolding), "holdingTorque");

		[HarmonyPostfix]
		internal static void PlayerHolding_SetWeaponTargets_Postfix(PlayerHolding __instance)
		{
			//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_005f: 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 (PossessionFreeAimLogic.ShouldRunPossessionFeatures() && ShouldApplyFpsModWeaponHold(__instance) && !(bool)FollowWeaponTargetField.GetValue(__instance))
			{
				FPSWeapon weapon = __instance.weapon;
				if ((!((Object)(object)weapon != (Object)null) || !PossessionRangedHold.IsRangedFpsWeapon(weapon)) && PossessionFreeAimLogic.TryGetCameraAim(out var aim, out var _))
				{
					Vector3 val = (Vector3)TargetUpField.GetValue(__instance);
					TargetForwardField.SetValue(__instance, aim);
					TargetUpField.SetValue(__instance, val);
				}
			}
		}

		[HarmonyPostfix]
		internal static void PlayerHolding_AddTorqueTowards_Postfix(PlayerHolding __instance)
		{
			//IL_006b: 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)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_00a9: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures() || !ShouldApplyFpsModWeaponHold(__instance) || (bool)FollowWeaponTargetField.GetValue(__instance))
			{
				return;
			}
			FPSWeapon weapon = __instance.weapon;
			if (!((Object)(object)weapon != (Object)null) || !PossessionRangedHold.IsRangedFpsWeapon(weapon))
			{
				float num = 1.75f;
				if (!(num <= 1.001f) && !((Object)(object)weapon?.rig == (Object)null))
				{
					Vector3 val = (Vector3)TargetForwardField.GetValue(__instance);
					Vector3 val2 = (Vector3)TargetUpField.GetValue(__instance);
					float num2 = (float)HoldingTorqueField.GetValue(__instance);
					float num3 = num - 1f;
					Vector3 val3 = (0f - Vector3.Angle(val, ((Component)weapon).transform.forward)) * Vector3.Cross(val, ((Component)weapon).transform.forward);
					val3 += 0.25f * (0f - Vector3.Angle(val2, ((Component)weapon).transform.up)) * Vector3.Cross(val2, ((Component)weapon).transform.up);
					weapon.rig.AddTorque(val3 * num2 * num3, (ForceMode)2);
				}
			}
		}

		[HarmonyPrefix]
		internal static void FPSWeapon_Shoot_Prefix(FPSWeapon __instance)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (PossessionFreeAimLogic.ShouldRunPossessionFeatures() && TryGetCrosshairAim(__instance, out var aim))
			{
				ApplyBarrelAimToTransform(((Component)__instance).transform, aim);
			}
		}

		private static void ApplyBarrelAimToTransform(Transform transform, Vector3 aim)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0043: 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_0045: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if ((Object)(object)transform == (Object)null || ((Vector3)(ref aim)).sqrMagnitude < 0.0001f)
			{
				return;
			}
			ShootPosition componentInChildren = ((Component)transform).GetComponentInChildren<ShootPosition>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Vector3 forward = ((Component)componentInChildren).transform.forward;
				if (((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
				{
					Quaternion val = Quaternion.FromToRotation(forward, aim);
					transform.rotation = val * transform.rotation;
					return;
				}
			}
			transform.rotation = Quaternion.LookRotation(aim, Vector3.up);
		}

		private static bool ShouldApplyFpsModWeaponHold(PlayerHolding holding)
		{
			if ((Object)(object)holding?.weapon == (Object)null || !IsFpsWeaponPossession(holding))
			{
				return false;
			}
			object? value = CamField.GetValue(holding);
			object? obj = ((value is Transform) ? value : null);
			CameraAbilityPossess val = ((obj != null) ? ((Component)obj).GetComponentInParent<CameraAbilityPossess>() : null);
			if ((Object)(object)val?.currentUnit?.data != (Object)null)
			{
				return AimExclusionStore.ShouldApplyModWeaponHold(val.currentUnit.data);
			}
			return false;
		}

		private static bool ShouldApplyFpsCrosshairAim(PlayerHolding holding)
		{
			if ((Object)(object)holding?.weapon == (Object)null || !IsFpsWeaponPossession(holding))
			{
				return false;
			}
			object? value = CamField.GetValue(holding);
			object? obj = ((value is Transform) ? value : null);
			CameraAbilityPossess val = ((obj != null) ? ((Component)obj).GetComponentInParent<CameraAbilityPossess>() : null);
			if ((Object)(object)val?.currentUnit != (Object)null)
			{
				return PossessionFreeAimLogic.ShouldApplyCrosshairAim(val.currentUnit);
			}
			return false;
		}

		private static bool IsFpsWeaponPossession(PlayerHolding holding)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			if ((Object)(object)holding?.weapon == (Object)null)
			{
				return false;
			}
			object? value = CamField.GetValue(holding);
			Transform val = (Transform)((value is Transform) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			CameraAbilityPossess componentInParent = ((Component)val).GetComponentInParent<CameraAbilityPossess>();
			if ((Object)(object)componentInParent != (Object)null && componentInParent.IsPossessing)
			{
				return (int)componentInParent.cameraMode == 1;
			}
			return false;
		}

		private static bool TryGetCrosshairAim(FPSWeapon weapon, out Vector3 aim)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			aim = default(Vector3);
			if ((Object)(object)weapon == (Object)null)
			{
				return false;
			}
			PlayerHolding componentInParent = ((Component)weapon).GetComponentInParent<PlayerHolding>();
			if ((Object)(object)componentInParent == (Object)null || !ShouldApplyFpsCrosshairAim(componentInParent))
			{
				return false;
			}
			object? value = CamField.GetValue(componentInParent);
			object? obj = ((value is Transform) ? value : null);
			DataHandler data = ((obj != null) ? ((Component)obj).GetComponentInParent<CameraAbilityPossess>() : null)?.currentUnit?.data;
			float aimDistanceForHandler = PossessionCrosshairAim.GetAimDistanceForHandler(data);
			if (PossessionCrosshairAim.TryGetAimDirection(data, aimDistanceForHandler, out aim, out var _))
			{
				return ((Vector3)(ref aim)).sqrMagnitude > 0.0001f;
			}
			if (!PossessionFreeAimLogic.TryGetCameraAim(out aim))
			{
				return false;
			}
			return ((Vector3)(ref aim)).sqrMagnitude > 0.0001f;
		}
	}
	internal static class GameStatePatches
	{
		public static void EnterBattleState_Postfix()
		{
			PossessionFreeAimLogic.InvalidateNonCombatUiCache();
			PossessionFreeAimLogic.InvalidatePossessionGameplayCache();
			PossessionFreeAimLogic.ClearPossessCache();
			HeadshotBriefFall.ResetBattleTracking();
			BattleMeleeDashStore.Clear();
			PossessionAutoShootStore.Clear();
			BattleStateHelper.InvalidateCache();
		}

		public static void EnterPlacementState_Postfix()
		{
			BattleMeleeDashStore.Clear();
			PossessionAutoShootStore.Clear();
			PossessionFreeAimLogic.InvalidateNonCombatUiCache();
			PossessionFreeAimLogic.InvalidatePossessionGameplayCache();
			PossessionFreeAimLogic.ClearPossessCache();
			PossessionZoom.OnPossessExit();
			PossessionCrosshairAim.ClearSmoothingCache();
			PossessionUnitTargetQuery.ClearCache();
			PossessionMouseLookPatches.ResetSavedSensitivity();
			BattleStateHelper.InvalidateCache();
		}

		public static void EnterNoneState_Postfix()
		{
			PossessionFreeAimLogic.InvalidateNonCombatUiCache();
			PossessionFreeAimLogic.InvalidatePossessionGameplayCache();
			PossessionFreeAimLogic.ClearPossessCache();
			BattleStateHelper.InvalidateCache();
		}
	}
	internal static class HeadshotBriefFall
	{
		[CompilerGenerated]
		private sealed class <StaggerFollowUp>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public DataHandler victimData;

			public float fallSeconds;

			public GameObject particleInstance;

			private float <elapsed>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<elapsed>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((Object)(object)victimData != (Object)null && !victimData.Dead && <elapsed>5__2 < fallSeconds)
				{
					<elapsed>5__2 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if ((Object)(object)particleInstance != (Object)null)
				{
					Object.Destroy((Object)(object)particleInstance);
				}
				if ((Object)(object)victimData == (Object)null || victimData.Dead)
				{
					return false;
				}
				EndRagdollState(victimData);
				ApplyGetUpNudge(victimData);
				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();
			}
		}

		private const float GetUpVerticalForce = 1f;

		private static readonly HashSet<int> StaggeredVictims = new HashSet<int>();

		internal static float GetMinStaggerDamage(DataHandler victimData)
		{
			int instanceID = ((Object)((Component)victimData).transform.root).GetInstanceID();
			if (!StaggeredVictims.Contains(instanceID))
			{
				return HeadshotFeedbackConfig.FirstStaggerDamageThreshold;
			}
			return HeadshotFeedbackConfig.RepeatStaggerDamageThreshold;
		}

		internal static void ResetBattleTracking()
		{
			StaggeredVictims.Clear();
			LimbDamageLogic.ResetHeadDamageTracking();
		}

		internal static void Apply(DataHandler victimData, float damage, GameObject particleInstance)
		{
			if ((Object)(object)victimData == (Object)null || victimData.Dead || !victimData.canFall || (Object)(object)victimData.head == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)((Component)victimData).transform.root).GetInstanceID();
			float minStaggerDamage = GetMinStaggerDamage(victimData);
			if (!(damage < minStaggerDamage))
			{
				float num = (StaggeredVictims.Contains(instanceID) ? HeadshotFeedbackConfig.GetRepeatStunBaseSeconds() : HeadshotFeedbackConfig.GetFirstStunBaseSeconds());
				StaggeredVictims.Add(instanceID);
				float num2 = Mathf.Max(1f, HeadshotFeedbackConfig.DamageStep);
				float num3 = num + (damage - minStaggerDamage) / num2 * HeadshotFeedbackConfig.StunSecondsPer50Damage;
				victimData.fallTime = Mathf.Max(victimData.fallTime, num3);
				ApplyEyeStartle(victimData, num3);
				if ((Object)(object)Plugin.Instance != (Object)null)
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(StaggerFollowUp(victimData, particleInstance, num3));
				}
			}
		}

		[IteratorStateMachine(typeof(<StaggerFollowUp>d__5))]
		private static IEnumerator StaggerFollowUp(DataHandler victimData, GameObject particleInstance, float fallSeconds)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StaggerFollowUp>d__5(0)
			{
				victimData = victimData,
				particleInstance = particleInstance,
				fallSeconds = fallSeconds
			};
		}

		private static void EndRagdollState(DataHandler victimData)
		{
			if (victimData.fallTime > 0f)
			{
				victimData.fallTime = -1f;
			}
		}

		private static void ApplyGetUpNudge(DataHandler victimData)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody val = null;
			if ((Object)(object)victimData.torso != (Object)null)
			{
				val = ((Component)victimData.torso).GetComponent<Rigidbody>();
			}
			if ((Object)(object)val == (Object)null && (Object)(object)victimData.mainRig != (Object)null)
			{
				val = victimData.mainRig;
			}
			if ((Object)(object)val != (Object)null)
			{
				val.AddForce(Vector3.up * 1f, (ForceMode)2);
			}
		}

		private static void ApplyEyeStartle(DataHandler victimData, float duration)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			if ((Object)(object)GooglyEyes.instance == (Object)null)
			{
				return;
			}
			EyeSpawner componentInChildren = ((Component)victimData).GetComponentInChildren<EyeSpawner>();
			if (componentInChildren?.spawnedEyes == null)
			{
				return;
			}
			for (int i = 0; i < componentInChildren.spawnedEyes.Count; i++)
			{
				GooglyEye val = componentInChildren.spawnedEyes[i];
				if (!((Object)(object)val == (Object)null) && (int)val.currentEyeState != 2)
				{
					GooglyEyes.instance.Startle(val, duration);
				}
			}
		}
	}
	internal static class HeadshotFeedbackAudio
	{
		[CompilerGenerated]
		private sealed class <PlayNextFrame>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public DataHandler victimData;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)victimData != (Object)null && (Object)(object)victimData.head != (Object)null)
					{
						PlayImmediate(victimData);
					}
					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();
			}
		}

		private const float HeadshotSoundVolume = 1.25f;

		private const string FallbackSoundRef1 = "Effects/PotionEffect";

		private const string FallbackSoundRef2 = "Farmer Hits/Throw_Potion";

		private static readonly FieldInfo ProjectilePrefabsField = typeof(ProjectilesSpawnManager).GetField("m_projectilePrefabs", BindingFlags.Instance | BindingFlags.NonPublic);

		private static string _resolvedSoundRef;

		private static bool _resolved;

		private static bool _warnedMissingSound;

		internal static void Play(DataHandler victimData, HitData hit)
		{
			if (!((Object)(object)victimData == (Object)null) && !((Object)(object)victimData.head == (Object)null))
			{
				if ((Object)(object)Plugin.Instance != (Object)null)
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(PlayNextFrame(victimData));
				}
				else
				{
					PlayImmediate(victimData);
				}
			}
		}

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

		private static void PlayImmediate(DataHandler victimData)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			SoundPlayer service = ServiceLocator.GetService<SoundPlayer>();
			if ((Object)(object)service == (Object)null)
			{
				return;
			}
			string text = ResolveSoundRef();
			if (!string.IsNullOrEmpty(text))
			{
				Transform head = victimData.head;
				Vector3 position = head.position;
				AudioPathData val = null;
				if (AudioPathData.ValidateAndAssignPathData(text, ref val, (Object)(object)((Component)victimData).gameObject) && val != null)
				{
					service.PlaySoundEffectNonAlloc(val, 1.25f, position, (MaterialType)0, head, 1f);
				}
				else
				{
					service.PlaySoundEffect(text, 1.25f, position, (MaterialType)0, head, 1f);
				}
			}
		}

		private static string ResolveSoundRef()
		{
			if (_resolved)
			{
				return _resolvedSoundRef;
			}
			_resolved = true;
			ProjectilesSpawnManager service = ServiceLocator.GetService<ProjectilesSpawnManager>();
			if ((Object)(object)service != (Object)null && ProjectilePrefabsField?.GetValue(service) is Projectile[] array)
			{
				foreach (Projectile val in array)
				{
					if (!((Object)(object)val == (Object)null) && ((Object)val).name.IndexOf("Potion", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						ProjectileHit componentInChildren = ((Component)val).GetComponentInChildren<ProjectileHit>(true);
						if (!((Object)(object)componentInChildren == (Object)null) && !string.IsNullOrEmpty(componentInChildren.SoundRef))
						{
							_resolvedSoundRef = componentInChildren.SoundRef;
							return _resolvedSoundRef;
						}
					}
				}
			}
			_resolvedSoundRef = "Effects/PotionEffect";
			AudioPathData val2 = null;
			if (AudioPathData.ValidateAndAssignPathData("Effects/PotionEffect", ref val2, (Object)null) && val2 != null)
			{
				return _resolvedSoundRef;
			}
			_resolvedSoundRef = "Farmer Hits/Throw_Potion";
			if (!_warnedMissingSound && !AudioPathData.ValidateAndAssignPathData("Farmer Hits/Throw_Potion", ref val2, (Object)null))
			{
				_warnedMissingSound = true;
				Plugin.LogWarning("Headshot potion sound: could not resolve P_Potion sound ref.");
			}
			return _resolvedSoundRef;
		}
	}
	internal static class HeadshotFeedbackConfig
	{
		internal const float RepeatStunBaseRatio = 0.25f;

		internal static bool Enabled = true;

		internal static float FirstHeadDamageMultiplier = 2f;

		internal static float RepeatHeadDamageMultiplier = 1.5f;

		internal static float FirstStaggerDamageThreshold = 200f;

		internal static float RepeatStaggerDamageThreshold = 400f;

		internal static float BaseStunSeconds = 2f;

		internal static float DamageStep = 50f;

		internal static float StunSecondsPer50Damage = 0.1f;

		internal static bool IsActive
		{
			get
			{
				if (Enabled)
				{
					return FirstPersonFreeAimConfig.Enabled;
				}
				return false;
			}
		}

		internal static float GetFirstStunBaseSeconds()
		{
			return BaseStunSeconds;
		}

		internal static float GetRepeatStunBaseSeconds()
		{
			return BaseStunSeconds * 0.25f;
		}

		internal static void Bind(ConfigFile config)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			Enabled = config.Bind<bool>("Combat.HeadshotFeedback", "Enabled", true, "Possessed headshot FX, stagger, and head damage rules. Also requires Possession.FirstPerson > FreeAim.").Value;
			FirstHeadDamageMultiplier = config.Bind<float>("Combat.HeadshotFeedback", "FirstHeadDamageMultiplier", 2f, new ConfigDescription("Projectile damage multiplier for the first possessed headshot on a victim.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 10f), Array.Empty<object>())).Value;
			RepeatHeadDamageMultiplier = config.Bind<float>("Combat.HeadshotFeedback", "RepeatHeadDamageMultiplier", 1.5f, new ConfigDescription("Projectile damage multiplier for later possessed headshots on the same victim.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 10f), Array.Empty<object>())).Value;
			FirstStaggerDamageThreshold = config.Bind<float>("Combat.HeadshotFeedback", "FirstStaggerDamageThreshold", 200f, new ConfigDescription("Minimum effective damage for the first knockdown on a victim.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 5000f), Array.Empty<object>())).Value;
			RepeatStaggerDamageThreshold = config.Bind<float>("Combat.HeadshotFeedback", "RepeatStaggerDamageThreshold", 400f, new ConfigDescription("Minimum effective damage for later knockdowns on the same victim.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 5000f), Array.Empty<object>())).Value;
			BaseStunSeconds = config.Bind<float>("Combat.HeadshotFeedback", "BaseStunSeconds", 2f, new ConfigDescription("First knockdown base duration in seconds. Repeat knockdown base is 25% of this (75% shorter).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 30f), Array.Empty<object>())).Value;
			DamageStep = config.Bind<float>("Combat.HeadshotFeedback", "DamageStep", 50f, new ConfigDescription("Damage chunk size used when adding bonus stun time over the threshold.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 1000f), Array.Empty<object>())).Value;
			StunSecondsPer50Damage = config.Bind<float>("Combat.HeadshotFeedback", "StunSecondsPer50Damage", 0.1f, new ConfigDescription("Extra stun seconds added per DamageStep of effective damage over the stagger threshold.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>())).Value;
		}
	}
	internal static class HeadshotFeedbackLogic
	{
		private const float CooldownSeconds = 0.12f;

		private static float _lastPlayTime = float.NegativeInfinity;

		internal static bool TryGetPossessedEnemyHeadshot(ProjectileHit projectile, HitData hit, out DataHandler victimData)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			victimData = null;
			if (!HeadshotFeedbackConfig.IsActive)
			{
				return false;
			}
			if ((Object)(object)projectile == (Object)null || (Object)(object)hit?.rigidbody == (Object)null)
			{
				return false;
			}
			if (!LimbDamageLogic.IsHeadHit(hit))
			{
				return false;
			}
			if ((Object)(object)((Component)hit.transform).GetComponentInParent<Damagable>() == (Object)null)
			{
				return false;
			}
			CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
			if ((Object)(object)possess == (Object)null || !possess.IsPossessing || (Object)(object)possess.currentUnit == (Object)null)
			{
				return false;
			}
			TeamHolder component = ((Component)projectile).GetComponent<TeamHolder>();
			if ((Object)(object)component?.spawner == (Object)null)
			{
				return false;
			}
			Unit componentInParent = component.spawner.GetComponentInParent<Unit>();
			if ((Object)(object)componentInParent != (Object)(object)possess.currentUnit)
			{
				return false;
			}
			victimData = ((Component)hit.rigidbody).GetComponentInParent<DataHandler>();
			if ((Object)(object)victimData?.unit == (Object)null)
			{
				return false;
			}
			if (victimData.unit.Team == componentInParent.Team)
			{
				return false;
			}
			return true;
		}

		internal static void TryPlay(ProjectileHit projectile, HitData hit)
		{
			if (HeadshotFeedbackConfig.IsActive && TryGetPossessedEnemyHeadshot(projectile, hit, out var victimData) && !(victimData.fallTime > 0f) && !(Time.time - _lastPlayTime < 0.12f))
			{
				bool isRepeatHeadDamage = LimbDamageLogic.IsRepeatHeadDamage(victimData);
				float effectiveProjectileDamage = LimbDamageLogic.GetEffectiveProjectileDamage(projectile.damage, hit, isRepeatHeadDamage);
				if (!(effectiveProjectileDamage < HeadshotBriefFall.GetMinStaggerDamage(victimData)))
				{
					_lastPlayTime = Time.time;
					LimbDamageLogic.MarkHeadDamaged(victimData);
					HeadshotFeedbackAudio.Play(victimData, hit);
					GameObject particleInstance = HeadshotPotionParticles.SpawnAtHead(victimData);
					HeadshotBriefFall.Apply(victimData, effectiveProjectileDamage, particleInstance);
				}
			}
		}
	}
	internal static class HeadshotPotionParticles
	{
		private static readonly FieldInfo ProjectilePrefabsField = typeof(ProjectilesSpawnManager).GetField("m_projectilePrefabs", BindingFlags.Instance | BindingFlags.NonPublic);

		private static GameObject _potionEffectPrefab;

		private static bool _resolved;

		private static bool _warnedMissingPrefab;

		internal static GameObject SpawnAtHead(DataHandler victimData)
		{
			//IL_0052: 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)
			if ((Object)(object)victimData == (Object)null || victimData.Dead || (Object)(object)victimData.head == (Object)null)
			{
				return null;
			}
			GameObject val = ResolvePotionEffectPrefab();
			if ((Object)(object)val == (Object)null)
			{
				if (!_warnedMissingPrefab)
				{
					_warnedMissingPrefab = true;
					Plugin.LogWarning("Headshot potion particles: could not find E_PotionEffect prefab.");
				}
				return null;
			}
			Transform head = victimData.head;
			GameObject obj = Object.Instantiate<GameObject>(val, head.position, head.rotation, head);
			StripGameplayComponents(obj);
			PlayParticles(obj);
			return obj;
		}

		private static void StripGameplayComponents(GameObject instance)
		{
			PotionEffect[] componentsInChildren = instance.GetComponentsInChildren<PotionEffect>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren[i]);
			}
			PlaySoundEffect[] componentsInChildren2 = instance.GetComponentsInChildren<PlaySoundEffect>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren2[i]);
			}
			DodgeMove[] componentsInChildren3 = instance.GetComponentsInChildren<DodgeMove>(true);
			for (int i = 0; i < componentsInChildren3.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren3[i]);
			}
			DelayEvent[] componentsInChildren4 = instance.GetComponentsInChildren<DelayEvent>(true);
			for (int i = 0; i < componentsInChildren4.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren4[i]);
			}
		}

		private static void PlayParticles(GameObject instance)
		{
			ParticleSystem[] componentsInChildren = instance.GetComponentsInChildren<ParticleSystem>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].Play();
			}
		}

		private static GameObject ResolvePotionEffectPrefab()
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (_resolved)
			{
				return _potionEffectPrefab;
			}
			_resolved = true;
			ProjectilesSpawnManager service = ServiceLocator.GetService<ProjectilesSpawnManager>();
			if ((Object)(object)service != (Object)null && ProjectilePrefabsField?.GetValue(service) is Projectile[] array)
			{
				foreach (Projectile val in array)
				{
					if ((Object)(object)val == (Object)null || ((Object)val).name.IndexOf("Potion", StringComparison.OrdinalIgnoreCase) < 0)
					{
						continue;
					}
					ProjectileHit componentInChildren = ((Component)val).GetComponentInChildren<ProjectileHit>(true);
					if (componentInChildren?.objectsToSpawn == null)
					{
						continue;
					}
					for (int j = 0; j < componentInChildren.objectsToSpawn.Length; j++)
					{
						ObjectToSpawn val2 = componentInChildren.objectsToSpawn[j];
						if (!((Object)(object)val2?.objectToSpawn == (Object)null) && (Object)(object)val2.objectToSpawn.GetComponentInChildren<PotionEffect>(true) != (Object)null)
						{
							_potionEffectPrefab = val2.objectToSpawn;
							return _potionEffectPrefab;
						}
					}
				}
			}
			PotionEffect[] array2 = Resources.FindObjectsOfTypeAll<PotionEffect>();
			foreach (PotionEffect val3 in array2)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					Scene scene = ((Component)val3).gameObject.scene;
					if (!((Scene)(ref scene)).IsValid())
					{
						_potionEffectPrefab = ((Component)val3).gameObject;
						return _potionEffectPrefab;
					}
				}
			}
			return null;
		}
	}
	internal static class LimbDamageConfig
	{
		internal static bool Enabled = true;

		internal static float LimbMultiplier = 0.75f;

		internal static void Bind(ConfigFile config)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			Enabled = config.Bind<bool>("Combat.LimbDamage", "Enabled", true, "Reduce projectile damage when hitting arms or legs instead of torso/head.").Value;
			LimbMultiplier = config.Bind<float>("Combat.LimbDamage", "LimbMultiplier", 0.75f, new ConfigDescription("Projectile damage multiplier for arm and leg hits (1 = full damage, 0.75 = 75%).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 1f), Array.Empty<object>())).Value;
		}
	}
	internal static class LimbDamageLogic
	{
		private static readonly HashSet<int> HeadDamagedVictims = new HashSet<int>();

		internal static void ApplyHeadDamageAdjustment(ref float damage, HitData hit, bool isRepeat)
		{
			if (IsHeadHit(hit))
			{
				DamageMultiplier component = ((Component)hit.rigidbody).GetComponent<DamageMultiplier>();
				float num = (((Object)(object)component != (Object)null) ? component.multiplier : 1f);
				float num2 = (isRepeat ? HeadshotFeedbackConfig.RepeatHeadDamageMultiplier : HeadshotFeedbackConfig.FirstHeadDamageMultiplier);
				if (num > 0f)
				{
					damage *= num2 / num;
				}
			}
		}

		internal static float GetEffectiveProjectileDamage(float baseDamage, HitData hit, bool isRepeatHeadDamage)
		{
			if ((Object)(object)hit?.rigidbody == (Object)null)
			{
				return baseDamage;
			}
			if (IsHeadHit(hit))
			{
				return baseDamage * (isRepeatHeadDamage ? HeadshotFeedbackConfig.RepeatHeadDamageMultiplier : HeadshotFeedbackConfig.FirstHeadDamageMultiplier);
			}
			DamageMultiplier component = ((Component)hit.rigidbody).GetComponent<DamageMultiplier>();
			if ((Object)(object)component != (Object)null)
			{
				return baseDamage * component.multiplier;
			}
			return baseDamage;
		}

		internal static void ResetHeadDamageTracking()
		{
			HeadDamagedVictims.Clear();
		}

		internal static float GetProjectileLimbMultiplier(HitData hit)
		{
			if (!LimbDamageConfig.Enabled || (Object)(object)hit?.rigidbody == (Object)null)
			{
				return 1f;
			}
			DataHandler componentInParent = ((Component)hit.rigidbody).GetComponentInParent<DataHandler>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return 1f;
			}
			if (IsCoreHit(((Component)hit.rigidbody).transform, componentInParent))
			{
				return 1f;
			}
			if (IsLimbHit(((Component)hit.rigidbody).transform, componentInParent))
			{
				return LimbDamageConfig.LimbMultiplier;
			}
			return 1f;
		}

		internal static bool IsHeadHit(HitData hit)
		{
			if ((Object)(object)hit?.rigidbody == (Object)null)
			{
				return false;
			}
			DataHandler componentInParent = ((Component)hit.rigidbody).GetComponentInParent<DataHandler>();
			if ((Object)(object)componentInParent?.head == (Object)null)
			{
				return false;
			}
			Transform transform = ((Component)hit.rigidbody).transform;
			if (MatchesPart(transform, componentInParent.head))
			{
				return true;
			}
			if ((Object)(object)((Component)transform).GetComponentInParent<Head>() != (Object)null)
			{
				return true;
			}
			return false;
		}

		internal static bool IsRepeatHeadDamage(DataHandler victimData)
		{
			return HeadDamagedVictims.Contains(((Object)((Component)victimData).transform.root).GetInstanceID());
		}

		internal static void MarkHeadDamaged(DataHandler victimData)
		{
			HeadDamagedVictims.Add(((Object)((Component)victimData).transform.root).GetInstanceID());
		}

		private static bool IsCoreHit(Transform hitTransform, DataHandler data)
		{
			if ((Object)(object)hitTransform == (Object)null || (Object)(object)data == (Object)null)
			{
				return false;
			}
			if ((Object)(object)data.mainRig != (Object)null && (Object)(object)((Component)hitTransform).GetComponent<Rigidbody>() == (Object)(object)data.mainRig)
			{
				return true;
			}
			if (!MatchesPart(hitTransform, data.head) && !MatchesPart(hitTransform, data.torso))
			{
				return MatchesPart(hitTransform, ((Object)(object)data.hip != (Object)null) ? ((Component)data.hip).transform : null);
			}
			return true;
		}

		private static bool IsLimbHit(Transform hitTransform, DataHandler data)
		{
			if (!MatchesPart(hitTransform, data.leftHand) && !MatchesPart(hitTransform, data.rightHand) && !MatchesPart(hitTransform, data.leftArm) && !MatchesPart(hitTransform, data.rightArm) && !MatchesPart(hitTransform, data.legLeft) && !MatchesPart(hitTransform, data.legRight) && !MatchesPart(hitTransform, data.footLeft))
			{
				return MatchesPart(hitTransform, data.footRight);
			}
			return true;
		}

		private static bool MatchesPart(Transform hitTransform, Transform part)
		{
			if ((Object)(object)hitTransform == (Object)null || (Object)(object)part == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)hitTransform == (Object)(object)part))
			{
				return hitTransform.IsChildOf(part);
			}
			return true;
		}
	}
	internal static class LimbDamagePatches
	{
		public static void DoGameplayEffects_Prefix(ProjectileHit __instance, HitData hit, ref float __state)
		{
			__state = __instance.damage;
			float projectileLimbMultiplier = LimbDamageLogic.GetProjectileLimbMultiplier(hit);
			if (projectileLimbMultiplier < 1f)
			{
				__instance.damage *= projectileLimbMultiplier;
			}
			if (HeadshotFeedbackConfig.IsActive && HeadshotFeedbackLogic.TryGetPossessedEnemyHeadshot(__instance, hit, out var victimData))
			{
				bool isRepeat = LimbDamageLogic.IsRepeatHeadDamage(victimData);
				LimbDamageLogic.ApplyHeadDamageAdjustment(ref __instance.damage, hit, isRepeat);
			}
		}

		public static void DoGameplayEffects_Postfix(ProjectileHit __instance, HitData hit, ref float __state)
		{
			__instance.damage = __state;
			HeadshotFeedbackLogic.TryPlay(__instance, hit);
		}
	}
	internal static class ModInfo
	{
		public const string Author = "Pretz";

		public const string PluginGuid = "pretz.freeaim";

		public const string PluginName = "Free Aim";

		public const string Version = "1.0.0";
	}
	[BepInPlugin("pretz.freeaim", "Free Aim", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static Plugin Instance { get; private set; }

		internal static void LogWarning(string message)
		{
			Plugin instance = Instance;
			if (instance != null)
			{
				((BaseUnityPlugin)instance).Logger.LogWarning((object)message);
			}
		}

		internal static void LogInfo(string message)
		{
			Plugin instance = Instance;
			if (instance != null)
			{
				((BaseUnityPlugin)instance).Logger.LogInfo((object)message);
			}
		}

		private void Awake()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_098a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0997: Expected O, but got Unknown
			//IL_09b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bd: Expected O, but got Unknown
			//IL_055e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_0580: Expected O, but got Unknown
			//IL_0580: Expected O, but got Unknown
			//IL_08b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bf: Expected O, but got Unknown
			//IL_08d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e5: Expected O, but got Unknown
			Instance = this;
			LimbDamageConfig.Bind(((BaseUnityPlugin)this).Config);
			HeadshotFeedbackConfig.Bind(((BaseUnityPlugin)this).Config);
			FirstPersonFreeAimConfig.Bind(((BaseUnityPlugin)this).Config);
			AimExclusionStore.Load();
			PossessionFreeAimLogic.InitializeSceneHooks();
			((Component)this).gameObject.AddComponent<PossessionRangeUi>();
			((Component)this).gameObject.AddComponent<PossessionBattleDashToggle>();
			((Component)this).gameObject.AddComponent<PossessionAutoShootToggle>();
			((Component)this).gameObject.AddComponent<PossessionMagazineUi>();
			Harmony val = new Harmony("pretz.freeaim");
			int num = 0;
			num += Patch(val, AccessTools.Method(typeof(GameStateManager), "EnterPlacementState", (Type[])null, (Type[])null), typeof(GameStatePatches), null, "EnterPlacementState_Postfix");
			num += Patch(val, AccessTools.Method(typeof(GameStateManager), "EnterBattleState", (Type[])null, (Type[])null), typeof(GameStatePatches), null, "EnterBattleState_Postfix");
			num += Patch(val, AccessTools.Method(typeof(GameStateManager), "EnterNoneState", (Type[])null, (Type[])null), typeof(GameStatePatches), null, "EnterNoneState_Postfix");
			MethodInfo methodInfo = AccessTools.Method(typeof(ProjectileHit), "DoGameplayEffects", new Type[3]
			{
				typeof(HitData),
				typeof(float),
				typeof(Unit)
			}, (Type[])null);
			if (methodInfo != null)
			{
				num += Patch(val, methodInfo, typeof(LimbDamagePatches), "DoGameplayEffects_Prefix", "DoGameplayEffects_Postfix");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Limb damage: ProjectileHit.DoGameplayEffects patch skipped");
			}
			num += Patch(val, AccessTools.Method(typeof(PlayerHolding), "SetWeaponTargets", (Type[])null, (Type[])null), typeof(FirstPersonFreeAimPatches), null, "PlayerHolding_SetWeaponTargets_Postfix");
			num += Patch(val, AccessTools.Method(typeof(PlayerHolding), "AddTorqueTowards", (Type[])null, (Type[])null), typeof(FirstPersonFreeAimPatches), null, "PlayerHolding_AddTorqueTowards_Postfix");
			num += Patch(val, AccessTools.Method(typeof(FPSWeapon), "Shoot", (Type[])null, (Type[])null), typeof(FirstPersonFreeAimPatches), "FPSWeapon_Shoot_Prefix");
			num += Patch(val, AccessTools.Method(typeof(CameraAbilityPossess), "LateUpdate", (Type[])null, (Type[])null), typeof(PossessionFreeAimPatches), null, "LateUpdate_Postfix");
			num += Patch(val, AccessTools.Method(typeof(CameraAbilityPossess), "LateUpdate", (Type[])null, (Type[])null), typeof(PossessionHoldAttackPatches), null, "LateUpdate_Postfix");
			num += Patch(val, AccessTools.Method(typeof(PlayerWeaponHandler), "Update", (Type[])null, (Type[])null), typeof(PossessionHoldAttackPatches), null, "PlayerWeaponHandler_Update_Postfix");
			num += Patch(val, AccessTools.Method(typeof(CameraAbilityPossess), "EnterUnit", (Type[])null, (Type[])null), typeof(PossessionFreeAimPatches), null, "EnterUnit_Postfix");
			num += Patch(val, AccessTools.Method(typeof(CameraAbilityPossess), "ExitUnit", (Type[])null, (Type[])null), typeof(PossessionFreeAimPatches), null, "ExitUnit_Postfix");
			num += Patch(val, AccessTools.Method(typeof(CameraAbilityPossess), "UpdateMovementAndRotation", (Type[])null, (Type[])null), typeof(PossessionFreeAimPatches), null, "UpdateMovementAndRotation_Postfix");
			num += Patch(val, AccessTools.Method(typeof(CameraAbilityPossess), "ToggleFPS", (Type[])null, (Type[])null), typeof(PossessionFreeAimPatches), null, "ToggleFPS_Postfix");
			num += Patch(val, AccessTools.Method(typeof(CameraAbilityPossess), "FindTargetRig", new Type[1] { typeof(float) }, (Type[])null), typeof(PossessionFreeAimPatches), "FindTargetRig_Prefix");
			num += Patch(val, AccessTools.Method(typeof(MouseLook), "Update", (Type[])null, (Type[])null), typeof(PossessionMouseLookPatches), "Update_Prefix", "Update_Postfix");
			MethodInfo original = AccessTools.Method(typeof(WeaponHandler), "Attack", new Type[4]
			{
				typeof(Vector3),
				typeof(Rigidbody),
				typeof(Vector3),
				typeof(ForceWeapon)
			}, (Type[])null);
			Type[] array = new Type[4]
			{
				typeof(Vector3),
				typeof(Rigidbody),
				typeof(Vector3),
				typeof(bool)
			};
			MethodInfo original2 = AccessTools.Method(typeof(RangeWeapon), "Attack", array, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(MeleeWeapon), "Attack", array, (Type[])null);
			bool flag = true;
			if (Patch(val, original, typeof(PossessionAttackRangePatches), "WeaponHandler_Attack_BlockOutOfRange_Prefix") == 0)
			{
				flag = false;
			}
			else
			{
				num++;
			}
			if (Patch(val, methodInfo2, typeof(PossessionAttackRangePatches), "Weapon_Attack_BlockOutOfRange_Prefix") == 0)
			{
				flag = false;
			}
			else
			{
				num++;
			}
			num += Patch(val, original, typeof(PossessionFreeAimPatches), "WeaponHandler_Attack_Prefix");
			num += Patch(val, original2, typeof(PossessionFreeAimPatches), "Weapon_Attack_Prefix");
			num += Patch(val, methodInfo2, typeof(PossessionFreeAimPatches), "Weapon_Attack_Prefix");
			if (methodInfo2 != null)
			{
				try
				{
					val.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(PossessionMeleeDashPatches), "MeleeWeapon_Attack_Prefix", (Type[])null), new HarmonyMethod(typeof(PossessionMeleeDashPatches), "MeleeWeapon_Attack_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					num++;
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("Failed to patch battle dash MeleeWeapon.Attack: " + ex.Message));
				}
			}
			MethodInfo methodInfo3 = AccessTools.Method(typeof(WeaponForceAnimation), "DoEffect", (Type[])null, (Type[])null);
			if (methodInfo3 != null)
			{
				num += Patch(val, methodInfo3, typeof(PossessionMeleeDashPatches), "WeaponForceAnimation_DoEffect_Prefix");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Melee dash patch skipped: WeaponForceAnimation.DoEffect not found");
			}
			if (Patch(val, original, typeof(PossessionPossessInputPatches), "WeaponHandler_Attack_BackupCounter_Prefix", "WeaponHandler_Attack_RestoreCounter_Postfix") == 0)
			{
				flag = false;
			}
			else
			{
				num++;
			}
			if (Patch(val, original2, typeof(PossessionPossessInputPatches), "RangeWeapon_Attack_BlockOutOfRange_Prefix", "RangeWeapon_Attack_RestoreCounter_Postfix") == 0)
			{
				flag = false;
			}
			else
			{
				num++;
			}
			if (!flag)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"Possession range gate INACTIVE — out-of-range shots will not be blocked");
			}
			num += Patch(val, AccessTools.Method(typeof(FPSWeapon), "Shoot", (Type[])null, (Type[])null), typeof(PossessionAttackRangePatches), "FPSWeapon_Shoot_BlockOutOfRange_Prefix");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(FpsRangeWeaponHandler), "Shoot", new Type[2]
			{
				typeof(FPSWeapon),
				typeof(bool)
			}, (Type[])null);
			if (methodInfo4 != null)
			{
				num += Patch(val, methodInfo4, typeof(PossessionAttackRangePatches), "FpsRangeWeaponHandler_Shoot_Prefix");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Possession attack range patch skipped: FpsRangeWeaponHandler.Shoot not found");
			}
			MethodInfo methodInfo5 = AccessTools.Method(typeof(FpsRangeWeaponHandler), "ChargeUp", new Type[1] { typeof(FPSWeapon) }, (Type[])null);
			if (methodInfo5 != null)
			{
				num += Patch(val, methodInfo5, typeof(PossessionAttackRangePatches), "FpsRangeWeaponHandler_ChargeUp_Prefix");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Possession attack range patch skipped: FpsRangeWeaponHandler.ChargeUp not found");
			}
			MethodInfo methodInfo6 = AccessTools.Method(typeof(SwingHandler), "StartSwing", new Type[1] { typeof(FPSWeapon) }, (Type[])null);
			if (methodInfo6 != null)
			{
				num += Patch(val, methodInfo6, typeof(PossessionAttackRangePatches), "SwingHandler_StartSwing_Prefix");
				num += Patch(val, methodInfo6, typeof(PossessionMeleeDashPatches), null, "StartSwing_Postfix");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Possession attack range patch skipped: SwingHandler.StartSwing not found");
			}
			MethodInfo methodInfo7 = AccessTools.Method(typeof(CameraAbilityPossessUI), "UpdateCooldowns", new Type[9]
			{
				typeof(float),
				typeof(float),
				typeof(float),
				typeof(float),
				typeof(float),
				typeof(float),
				typeof(bool),
				typeof(bool),
				typeof(bool)
			}, (Type[])null);
			if (methodInfo7 != null)
			{
				num += Patch(val, methodInfo7, typeof(PossessionRangeUi), "UpdateCooldowns_Prefix");
				try
				{
					val.Patch((MethodBase)methodInfo7, (HarmonyMethod)null, new HarmonyMethod(typeof(PossessionBattleDashToggle), "UpdateCooldowns_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					num++;
					val.Patch((MethodBase)methodInfo7, (HarmonyMethod)null, new HarmonyMethod(typeof(PossessionAutoShootToggle), "UpdateCooldowns_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					num++;
				}
				catch (Exception ex2)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("Failed to patch battle dash possess UI postfix: " + ex2.Message));
				}
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Possession attack range patch skipped: CameraAbilityPossessUI.UpdateCooldowns not found");
			}
			Type type = AccessTools.TypeByName("InControl.BindingSourceType");
			MethodInfo methodInfo8 = ((type != null) ? AccessTools.Method(typeof(CameraAbilityPossessUI), "UpdatePrompts", new Type[1] { type }, (Type[])null) : AccessTools.Method(typeof(CameraAbilityPossessUI), "UpdatePrompts", (Type[])null, (Type[])null));
			if (methodInfo8 != null)
			{
				try
				{
					val.Patch((MethodBase)methodInfo8, (HarmonyMethod)null, new HarmonyMethod(typeof(PossessionBattleDashToggle), "UpdatePrompts_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					num++;
					val.Patch((MethodBase)methodInfo8, (HarmonyMethod)null, new HarmonyMethod(typeof(PossessionAutoShootToggle), "UpdatePrompts_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					num++;
				}
				catch (Exception ex3)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("Failed to patch battle dash UpdatePrompts postfix: " + ex3.Message));
				}
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Battle dash prompt patch skipped: CameraAbilityPossessUI.UpdatePrompts not found");
			}
			MethodInfo methodInfo9 = AccessTools.Method(typeof(RangeWeapon), "SetTeamHolder", new Type[2]
			{
				typeof(GameObject),
				typeof(Rigidbody)
			}, (Type[])null);
			if (methodInfo9 != null)
			{
				num += Patch(val, methodInfo9, typeof(PossessionBallisticAimPatches), "RangeWeapon_SetTeamHolder_Prefix");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Spread volley patch skipped: RangeWeapon.SetTeamHolder not found");
			}
			MethodInfo methodInfo10 = AccessTools.Method(typeof(RangeWeapon), "SetTargetableEffects", new Type[3]
			{
				typeof(GameObject),
				typeof(Vector3),
				typeof(Rigidbody)
			}, (Type[])null);
			if (methodInfo10 != null)
			{
				num += Patch(val, methodInfo10, typeof(PossessionBallisticAimPatches), "RangeWeapon_SetTargetableEffects_Prefix");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Homing aim patch skipped: RangeWeapon.SetTargetableEffects not found");
			}
			MethodInfo methodInfo11 = AccessTools.Method(typeof(SpellTarget), "GetTarget", (Type[])null, (Type[])null);
			if (methodInfo11 != null)
			{
				num += Patch(val, methodInfo11, typeof(PossessionHomingPatches), "SpellTarget_GetTarget_Prefix");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Homing aim patch skipped: SpellTarget.GetTarget not found");
			}
			MethodInfo methodInfo12 = AccessTools.Method(typeof(SpellTarget), "Release", (Type[])null, (Type[])null);
			if (methodInfo12 != null)
			{
				num += Patch(val, methodInfo12, typeof(PossessionHomingPatches), null, "SpellTarget_Release_Postfix");
			}
			MethodInfo methodInfo13 = AccessTools.Method(typeof(RangeWeapon), "Reload", (Type[])null, (Type[])null);
			if (methodInfo13 != null)
			{
				num += Patch(val, methodInfo13, typeof(PossessionMagazinePatches), "RangeWeapon_Reload_Prefix");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Magazine UI patch skipped: RangeWeapon.Reload not found");
			}
			MethodInfo methodInfo14 = AccessTools.Method(typeof(RangeWeapon), "SetProjectileStats", (Type[])null, (Type[])null);
			if (methodInfo14 != null)
			{
				num += Patch(val, methodInfo14, typeof(PossessionBallisticAimPatches), "RangeWeapon_SetProjectileStats_Prefix", "RangeWeapon_SetProjectileStats_Postfix");
				num += Patch(val, methodInfo14, typeof(PossessionMagazinePatches), null, "RangeWeapon_SetProjectileStats_Postfix");
			}
			MethodInfo methodInfo15 = AccessTools.Method(typeof(RangeWeapon), "GetSpawnDirection", (Type[])null, (Type[])null);
			if (methodInfo15 != null)
			{
				num += Patch(val, methodInfo15, typeof(PossessionBallisticAimPatches), "RangeWeapon_GetSpawnDirection_Prefix");
			}
			MethodInfo methodInfo16 = AccessTools.Method(typeof(RangeWeapon), "GetSpawnPosition", (Type[])null, (Type[])null);
			if (methodInfo16 != null)
			{
				num += Patch(val, methodInfo16, typeof(PossessionBallisticAimPatches), null, "RangeWeapon_GetSpawnPosition_Postfix");
			}
			MethodInfo methodInfo17 = AccessTools.Method(typeof(MoveTransform), "InitializeVelocity", (Type[])null, (Type[])null);
			if (methodInfo17 != null)
			{
				num += Patch(val, methodInfo17, typeof(PossessionBallisticAimPatches), null, "MoveTransform_InitializeVelocity_Postfix");
			}
			num += Patch(val, AccessTools.Method(typeof(Holdable), "BatchedUpdate", (Type[])null, (Type[])null), typeof(PossessionFreeAimPatches), null, "Holdable_BatchedUpdate_Postfix");
			num += Patch(val, AccessTools.DeclaredMethod(typeof(HoldingHandler), "DoPID", new Type[3]
			{
				typeof(PidDataInstance),
				typeof(HoldableDataInstance),
				typeof(float)
			}, (Type[])null), typeof(PossessionFreeAimPatches), "HoldingHandler_DoPID_Prefix");
			num += Patch(val, AccessTools.Method(typeof(MainMenuButtons), "Start", (Type[])null, (Type[])null), typeof(AimExclusionMenu), null, "MainMenuButtons_Start_Postfix");
			num += RegisterAimExclusionContentPatches(val);
			((BaseUnityPlugin)this).Logger.LogInfo((object)string.Format("Loaded v{0} by {1} — Harmony {2} patches", "1.0.0", "Pretz", num));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Projectile limb damage: " + (LimbDamageConfig.Enabled ? $"on ({LimbDamageConfig.LimbMultiplier:P0} on limbs)" : "off")));
			((BaseUnityPlugin)this).Logger.LogInfo((object)(HeadshotFeedbackConfig.IsActive ? ($"Headshot feedback: on (first stun {HeadshotFeedbackConfig.BaseStunSeconds:0.##}s, " + $"repeat {HeadshotFeedbackConfig.GetRepeatStunBaseSeconds():0.##}s, " + $"thresholds {HeadshotFeedbackConfig.FirstStaggerDamageThreshold:0.#}/" + $"{HeadshotFeedbackConfig.RepeatStaggerDamageThreshold:0.#})") : "Headshot feedback: off (config or free aim disabled)"));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Possession aiming: " + (FirstPersonFreeAimConfig.Enabled ? "on" : "off") + " (config: Possession.FirstPerson > FreeAim)"));
		}

		private int RegisterAimExclusionContentPatches(Harmony harmony)
		{
			int num = 0;
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(ContentDatabase), "RemoveUserUnitBlueprintAndEmptyFactionsCreated", new Type[1] { typeof(DatabaseID) }, (Type[])null);
				if (methodInfo != null)
				{
					num += Patch(harmony, methodInfo, typeof(AimExclusionStore), null, "RemoveUserUnitBlueprint_Postfix");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Aim exclusions: RemoveUserUnitBlueprintAndEmptyFactionsCreated patch skipped");
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Aim exclusion content patches failed: {arg}");
			}
			return num;
		}

		private int Patch(Harmony harmony, MethodBase original, Type patchClass, string prefix = null, string postfix = null, string transpiler = null)
		{
			//IL_0047: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			if (original == null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Patch target missing: " + patchClass.Name + "." + (prefix ?? postfix ?? transpiler)));
				return 0;
			}
			try
			{
				object obj = harmony;
				obj = original;
				obj = (object)((prefix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(patchClass, prefix, (Type[])null));
				obj = (object)((postfix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(patchClass, postfix, (Type[])null));
				obj = (object)((transpiler == null) ? ((HarmonyMethod)null) : new HarmonyMethod(patchClass, transpiler, (Type[])null));
				((Harmony)obj).Patch((MethodBase)obj, (HarmonyMethod)obj, (HarmonyMethod)obj, (HarmonyMethod)obj, (HarmonyMethod)null, (HarmonyMethod)null);
				return 1;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Failed to patch " + original.DeclaringType?.Name + "." + original.Name + ": " + ex.Message));
				return 0;
			}
		}
	}
	internal static class PossessionAttackRangeGate
	{
		internal struct RangeGateState
		{
			public bool GateActive;

			public bool CanAttack;

			public float AimDistance;

			public float MaxDistance;

			public Weapon ActiveWeapon;
		}

		private const float FallbackWeaponRange = 30f;

		private const float RangeSlack = 0.5f;

		private static readonly FieldInfo WeaponHandlerDataField = AccessTools.Field(typeof(WeaponHandler), "data");

		private static readonly FieldInfo ShootPositionField = AccessTools.Field(typeof(RangeWeapon), "shootPosition");

		internal static RangeGateState LastState;

		internal static bool IsEnabled => FirstPersonFreeAimConfig.Enabled;

		internal static float GetMaxAttackDistance(Weapon weapon)
		{
			float num = (((Object)(object)weapon != (Object)null && weapon.maxRange > 0f) ? weapon.maxRange : 30f);
			float num2 = Mathf.Max(0.01f, 1.25f);
			return num * num2;
		}

		internal static bool IsGateActive(DataHandler data)
		{
			if (IsEnabled && PossessionFreeAimLogic.ShouldRunPossessionFeatures() && PossessionFreeAimLogic.IsPossessedUnit(data))
			{
				return AimExclusionStore.ShouldApplyRangeGate(data);
			}
			return false;
		}

		internal static bool CanAttack(DataHandler data, Weapon weapon)
		{
			if (!IsGateActive(data))
			{
				return true;
			}
			if ((Object)(object)weapon == (Object)null)
			{
				return true;
			}
			if (!TryGetCrosshairAimDistance(data, weapon, out var distance))
			{
				return false;
			}
			return distance <= GetMaxAttackDistance(weapon) + 0.5f;
		}

		internal static bool ShouldBlockHandlerAttack(WeaponHandler handler, DataHandler data, ForceWeapon forceWeapon)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!IsGateActive(data))
			{
				return false;
			}
			Weapon vanillaActiveWeapon = GetVanillaActiveWeapon(handler, forceWeapon);
			if ((Object)(object)vanillaActiveWeapon == (Object)null)
			{
				return false;
			}
			return !CanAttack(data, vanillaActiveWeapon);
		}

		internal static Weapon GetVanillaActiveWeapon(WeaponHandler handler, ForceWeapon forceWeapon)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Invalid comparison between Unknown and I4
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Invalid comparison between Unknown and I4
			if ((Object)(object)handler == (Object)null)
			{
				return null;
			}
			Weapon val = (((Object)(object)handler.leftWeapon == (Object)null) ? handler.rightWeapon : ((!((Object)(object)handler.rightWeapon == (Object)null)) ? ((Random.value > 0.5f) ? handler.leftWeapon : handler.rightWeapon) : handler.leftWeapon));
			val = ((val != null) ? val.GetBestWeaponOnWeapon() : null);
			if ((Object)(object)handler.leftWeapon != (Object)null && (Object)(object)handler.rightWeapon != (Object)null)
			{
				if ((int)forceWeapon == 1)
				{
					val = handler.leftWeapon;
				}
				if ((int)forceWeapon == 2)
				{
					val = handler.rightWeapon;
				}
			}
			return val;
		}

		internal static Weapon ResolveAttackingWeapon(WeaponHandler handler, ForceWeapon forceWeapon)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return GetVanillaActiveWeapon(handler, forceWeapon);
		}

		internal static bool CanAttackLeft(WeaponHandler handler)
		{
			DataHandler handlerData = GetHandlerData(handler);
			if ((Object)(object)handler == (Object)null)
			{
				return true;
			}
			Weapon vanillaActiveWeapon = GetVanillaActiveWeapon(handler, (ForceWeapon)1);
			if (!((Object)(object)vanillaActiveWeapon == (Object)null))
			{
				return CanAttack(handlerData, vanillaActiveWeapon);
			}
			return true;
		}

		internal static bool CanAttackRight(WeaponHandler handler)
		{
			DataHandler handlerData = GetHandlerData(handler);
			if ((Object)(object)handler == (Object)null)
			{
				return true;
			}
			Weapon vanillaActiveWeapon = GetVanillaActiveWeapon(handler, (ForceWeapon)2);
			if (!((Object)(object)vanillaActiveWeapon == (Object)null))
			{
				return CanAttack(handlerData, vanillaActiveWeapon);
			}
			return true;
		}

		internal static bool CanAttackFpsWeapon(FPSWeapon fpsWeapon)
		{
			if ((Object)(object)fpsWeapon == (Object)null)
			{
				return true;
			}
			Weapon val = (Weapon)(((Object)(object)fpsWeapon.rangeWeapon != (Object)null) ? ((object)fpsWeapon.rangeWeapon) : ((object)fpsWeapon.meleeWeapon));
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			return CanAttack(val.connectedData, val);
		}

		internal static void RefreshState(WeaponHandler handler, DataHandler data)
		{
			LastState = default(RangeGateState);
			if (!IsGateActive(data) || (Object)(object)handler == (Object)null)
			{
				LastState.CanAttack = true;
				return;
			}
			LastState.GateActive = true;
			List<Weapon> list = CollectHeldWeapons(handler);
			if (list.Count == 0)
			{
				LastState.CanAttack = true;
				return;
			}
			foreach (Weapon item in list)
			{
				if (CanAttack(data, item))
				{
					LastState.CanAttack = true;
					LastState.ActiveWeapon = item;
					TryGetCrosshairAimDistance(data, item, out LastState.AimDistance);
					LastState.MaxDistance = GetMaxAttackDistance(item);
					return;
				}
			}
			Weapon val = list[0];
			LastState.CanAttack = false;
			LastState.ActiveWeapon = val;
			TryGetCrosshairAimDistance(data, val, out LastState.AimDistance);
			LastState.MaxDistance = GetMaxAttackDistance(val);
		}

		internal static void RefreshStateForFpsWeapon(FPSWeapon fpsWeapon)
		{
			if ((Object)(object)fpsWeapon == (Object)null)
			{
				return;
			}
			Weapon val = (Weapon)(((Object)(object)fpsWeapon.rangeWeapon != (Object)null) ? ((object)fpsWeapon.rangeWeapon) : ((object)fpsWeapon.meleeWeapon));
			DataHandler val2 = ((val != null) ? val.connectedData : null);
			WeaponHandler val3 = val2?.weaponHandler;
			if ((Object)(object)val3 != (Object)null)
			{
				RefreshState(val3, val2);
				return;
			}
			LastState = default(RangeGateState);
			if (!IsGateActive(val2) || (Object)(object)val == (Object)null)
			{
				LastState.CanAttack = true;
				return;
			}
			LastState.GateActive = true;
			LastState.ActiveWeapon = val;
			LastState.CanAttack = CanAttack(val2, val);
			TryGetCrosshairAimDistance(val2, val, out LastState.AimDistance);
			LastState.MaxDistance = GetMaxAttackDistance(val);
		}

		internal static bool TryGetCrosshairAimDistance(DataHandler data, Weapon weapon, out float distance)
		{
			//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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			distance = 0f;
			if ((Object)(object)data == (Object)null || (Object)(object)weapon == (Object)null)
			{
				return false;
			}
			Vector3 weaponOrigin = GetWeaponOrigin(data, weapon);
			float crosshairQueryDistance = GetCrosshairQueryDistance(data, weapon);
			if (!PossessionCrosshairAim.TryGetCrosshairAimPoint(crosshairQueryDistance, out var aimPoint))
			{
				if (!PossessionFreeAimLogic.TryGetCameraAim(out var aim))
				{
					return false;
				}
				aimPoint = weaponOrigin + aim * crosshairQueryDistance;
			}
			distance = Vector3.Distance(weaponOrigin, aimPoint);
			return true;
		}

		private static float GetCrosshairQueryDistance(DataHandler data, Weapon weapon)
		{
			RangeWeapon val = (RangeWeapon)(object)((weapon is RangeWeapon) ? weapon : null);
			if (val != null)
			{
				return PossessionCrosshairAim.GetAimDistanceForWeapon(val);
			}
			return PossessionCrosshairAim.GetAimDistanceForHandler(data);
		}

		private static List<Weapon> CollectHeldWeapons(WeaponHandler handler)
		{
			List<Weapon> list = new List<Weapon>(2);
			if ((Object)(object)handler.leftWeapon != (Object)null)
			{
				list.Add(handler.leftWeapon);
			}
			if ((Object)(object)handler.rightWeapon != (Object)null)
			{
				list.Add(handler.rightWeapon);
			}
			return list;
		}

		private static Vector3 GetWeaponOrigin(DataHandler data, Weapon weapon)
		{
			//IL_0042: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			RangeWeapon val = (RangeWeapon)(object)((weapon is RangeWeapon) ? weapon : null);
			if (val != null)
			{
				object? obj = ShootPositionField?.GetValue(val);
				Transform val2 = (Transform)((obj is Transform) ? obj : null);
				if (val2 != null && (Object)(object)val2 != (Object)null)
				{
					return val2.position;
				}
				return ((Component)val).transform.position;
			}
			return PossessionCrosshairAim.GetAimOrigin(data);
		}

		internal static DataHandler GetHandlerData(WeaponHandler handler)
		{
			if ((Object)(object)handler == (Object)null)
			{
				return PossessionFreeAimLogic.GetPossess()?.currentUnit?.data;
			}
			object? obj = WeaponHandlerDataField?.GetValue(handler);
			DataHandler val = (DataHandler)((obj is DataHandler) ? obj : null);
			if (val != null)
			{
				return val;
			}
			return ((Component)handler).GetComponentInParent<Unit>()?.data;
		}
	}
	internal static class PossessionAttackRangePatches
	{
		[HarmonyPriority(800)]
		internal static bool WeaponHandler_Attack_BlockOutOfRange_Prefix(WeaponHandler __instance, ForceWeapon forceWeapon)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			DataHandler handlerData = PossessionAttackRangeGate.GetHandlerData(__instance);
			return !PossessionAttackRangeGate.ShouldBlockHandlerAttack(__instance, handlerData, forceWeapon);
		}

		[HarmonyPriority(800)]
		internal static bool Weapon_Attack_BlockOutOfRange_Prefix(Weapon __instance, bool recursive)
		{
			if (recursive)
			{
				return true;
			}
			if (!PossessionAttackRangeGate.IsGateActive((__instance != null) ? __instance.connectedData : null))
			{
				return true;
			}
			return PossessionAttackRangeGate.CanAttack(__instance.connectedData, __instance);
		}

		[HarmonyPriority(800)]
		internal static bool FPSWeapon_Shoot_BlockOutOfRange_Prefix(FPSWeapon __instance)
		{
			return PossessionAttackRangeGate.CanAttackFpsWeapon(__instance);
		}

		[HarmonyPriority(800)]
		internal static bool FpsRangeWeaponHandler_Shoot_Prefix(FPSWeapon weapon)
		{
			return PossessionAttackRangeGate.CanAttackFpsWeapon(weapon);
		}

		[HarmonyPriority(800)]
		internal static bool FpsRangeWeaponHandler_ChargeUp_Prefix(FPSWeapon weapon)
		{
			if ((Object)(object)weapon?.rangeWeapon == (Object)null)
			{
				return true;
			}
			if (!PossessionAttackRangeGate.IsGateActive(((Weapon)weapon.rangeWeapon).connectedData))
			{
				return true;
			}
			return PossessionAttackRangeGate.CanAttack(((Weapon)weapon.rangeWeapon).connectedData, (Weapon)(object)weapon.rangeWeapon);
		}

		[HarmonyPriority(800)]
		internal static bool SwingHandler_StartSwing_Prefix(FPSWeapon fpsWeapon)
		{
			return PossessionAttackRangeGate.CanAttackFpsWeapon(fpsWeapon);
		}
	}
	internal static class PossessionAutoShootStore
	{
		private static readonly HashSet<int> DisabledInstanceIds = new HashSet<int>();

		internal static void Clear()
		{
			DisabledInstanceIds.Clear();
		}

		internal static bool IsEnabled(DataHandler data)
		{
			if ((Object)(object)data == (Object)null)
			{
				return false;
			}
			return !DisabledInstanceIds.Contains(((Object)((Component)data).transform.root).GetInstanceID());
		}

		internal static void Toggle(DataHandler data)
		{
			if (!((Object)(object)data == (Object)null))
			{
				int instanceID = ((Object)((Component)data).transform.root).GetInstanceID();
				if (DisabledInstanceIds.Contains(instanceID))
				{
					DisabledInstanceIds.Remove(instanceID);
				}
				else
				{
					DisabledInstanceIds.Add(instanceID);
				}
			}
		}
	}
	internal sealed class PossessionAutoShootToggle : MonoBehaviour
	{
		internal const string AutoShootSuffixMarker = " · Auto Shoot ";

		private static readonly FieldInfo MainControlsPromptField = AccessTools.Field(typeof(CameraAbilityPossessUI), "mainControlsPrompt");

		private static readonly Color AutoShootOnColor = new Color(0.85f, 1f, 0.85f, 0.98f);

		private static readonly Color AutoShootOffColor = new Color(1f, 0.45f, 0.45f, 0.98f);

		private void LateUpdate()
		{
			if (TryGetActiveAutoShootContext(out var possess, out var data))
			{
				TryHandleHotkey(possess, data);
			}
		}

		internal static void UpdateCooldowns_Postfix(CameraAbilityPossessUI __instance)
		{
			if ((Object)(object)__instance == (Object)null || !__instance.UIActive)
			{
				return;
			}
			if (!BattleStateHelper.IsBattleActive())
			{
				ClearPrompt(__instance);
				return;
			}
			CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
			if ((Object)(object)possess == (Object)null || !possess.IsPossessing)
			{
				ClearPrompt(__instance);
			}
			else
			{
				UpdateMainControlsPrompt(__instance, possess.currentUnit?.data);
			}
		}

		internal static void UpdatePrompts_Postfix(CameraAbilityPossessUI __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && __instance.UIActive && BattleStateHelper.IsBattleActive())
			{
				CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
				if (!((Object)(object)possess == (Object)null) && possess.IsPossessing)
				{
					UpdateMainControlsPrompt(__instance, possess.currentUnit?.data);
				}
			}
		}

		internal static string StripAutoShootSuffix(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			int num = text.IndexOf(" · Auto Shoot ", StringComparison.Ordinal);
			if (num < 0)
			{
				return text;
			}
			return text.Substring(0, num);
		}

		private static bool TryGetActiveAutoShootContext(out CameraAbilityPossess possess, out DataHandler data)
		{
			possess = null;
			data = null;
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures())
			{
				return false;
			}
			if (!BattleStateHelper.IsBattleActive())
			{
				return false;
			}
			possess = PossessionFreeAimLogic.GetPossess();
			if ((Object)(object)possess == (Object)null || !possess.IsPossessing)
			{
				return false;
			}
			data = possess.currentUnit?.data;
			return AimExclusionStore.ShouldShowAutoShootToggle(data);
		}

		private static void TryHandleHotkey(CameraAbilityPossess possess, DataHandler data)
		{
			if (!AimExclusionMenu.IsOpen && !IsPausedOrMatchOver(possess) && AimExclusionStore.WasAutoShootToggleKeyPressed())
			{
				PossessionAutoShootStore.Toggle(data);
				CameraAbilityPossessUI val = PossessUiFrom(possess);
				if (val != null)
				{
					UpdateMainControlsPrompt(val, data);
				}
			}
		}

		private static CameraAbilityPossessUI PossessUiFrom(CameraAbilityPossess possess)
		{
			object? obj = AccessTools.Field(typeof(CameraAbilityPossess), "possessUI")?.GetValue(possess);
			return (CameraAbilityPossessUI)((obj is CameraAbilityPossessUI) ? obj : null);
		}

		private static bool IsPausedOrMatchOver(CameraAbilityPossess possess)
		{
			if ((Object)(object)possess == (Object)null)
			{
				return true;
			}
			Traverse val = Traverse.Create((object)possess);
			object value = val.Field("m_gameMode").GetValue<object>();
			if (value != null)
			{
				object obj = value.GetType().GetProperty("MatchOver")?.GetValue(value);
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				if (((uint)num & (flag ? 1u : 0u)) != 0)
				{
					return true;
				}
			}
			object value2 = val.Field("m_timeService").GetValue<object>();
			if (value2 == null)
			{
				return false;
			}
			object obj2 = value2.GetType().GetMethod("IsPaused")?.Invoke(value2, null);
			bool flag2 = default(bool);
			int num2;
			if (obj2 is bool)
			{
				flag2 = (bool)obj2;
				num2 = 1;
			}
			else
			{
				num2 = 0;
			}
			return (byte)((uint)num2 & (flag2 ? 1u : 0u)) != 0;
		}

		private static void ClearPrompt(CameraAbilityPossessUI ui)
		{
			if (!((Object)(object)ui == (Object)null))
			{
				Component mainPromptTmp = GetMainPromptTmp(ui);
				if (!((Object)(object)mainPromptTmp == (Object)null))
				{
					Type type = ((object)mainPromptTmp).GetType();
					string text = (type.GetProperty("text")?.GetValue(mainPromptTmp) as string) ?? string.Empty;
					type.GetProperty("text")?.SetValue(mainPromptTmp, StripAutoShootSuffix(text), null);
				}
			}
		}

		private static void UpdateMainControlsPrompt(CameraAbilityPossessUI ui, DataHandler data)
		{
			//IL_0065: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			Component mainPromptTmp = GetMainPromptTmp(ui);
			if (!((Object)(object)mainPromptTmp == (Object)null))
			{
				Type type = ((object)mainPromptTmp).GetType();
				string text = StripAutoShootSuffix((type.GetProperty("text")?.GetValue(mainPromptTmp) as string) ?? string.Empty);
				if (!AimExclusionStore.ShouldShowAutoShootToggle(data))
				{
					type.GetProperty("text")?.SetValue(mainPromptTmp, text, null);
					return;
				}
				string text2 = AimExclusionStore.FormatKeyName(AimExclusionStore.GetAutoShootToggleKey());
				bool flag = PossessionAutoShootStore.IsEnabled(data);
				string text3 = (flag ? "ON" : "OFF");
				type.GetProperty("text")?.SetValue(mainPromptTmp, text + " · Auto Shoot " + text3 + " [" + text2 + "]", null);
				type.GetProperty("color")?.SetValue(mainPromptTmp, flag ? AutoShootOnColor : AutoShootOffColor, null);
			}
		}

		private static Component GetMainPromptTmp(CameraAbilityPossessUI ui)
		{
			object obj = MainControlsPromptField?.GetValue(ui);
			if (obj == null)
			{
				return null;
			}
			object? obj2 = obj.GetType().GetProperty("Text")?.GetValue(obj);
			Component val = (Component)((obj2 is Component) ? obj2 : null);
			if (val != null)
			{
				return val;
			}
			Component val2 = (Component)((obj is Component) ? obj : null);
			if (val2 == null)
			{
				return null;
			}
			Type type = AccessTools.TypeByName("TMPro.TextMeshProUGUI");
			if (type == null)
			{
				return null;
			}
			return val2.GetComponent(type) ?? val2.GetComponentInChildren(type, true);
		}
	}
	internal static class PossessionBallisticAim
	{
		private sealed class FrameAimCacheEntry
		{
			public int Frame;

			public Vector3 AimPoint;

			public Vector3 AimDirection;

			public PossessionCrosshairAim.AimTarget AimTarget;

			public bool LaunchSolved;

			public Vector3 LaunchVelocity;

			public float PreferredSpeed;
		}

		[DefaultExecutionOrder(-10000)]
		private class UnitSurfaceHomingTarget : MonoBehaviour
		{
			private Rigidbody _rig;

			private Unit _unit;

			private Ray _aimRay;

			internal static Rigidbody Create(Unit unit, Ray aimRay, Vector3 initialPosition)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Expected O, but got Unknown
				//IL_0019: 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_0044: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("StayCombatFix Homing Surface Target");
				UnitSurfaceHomingTarget unitSurfaceHomingTarget = val.AddComponent<UnitSurfaceHomingTarget>();
				unitSurfaceHomingTarget._unit = unit;
				unitSurfaceHomingTarget._aimRay = aimRay;
				unitSurfaceHomingTarget._rig = val.AddComponent<Rigidbody>();
				unitSurfaceHomingTarget._rig.isKinematic = true;
				unitSurfaceHomingTarget._rig.useGravity = false;
				unitSurfaceHomingTarget.ApplyPosition(initialPosition);
				return unitSurfaceHomingTarget._rig;
			}

			private void Update()
			{
				//IL_0046: 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_0087: Unknown result type (might be due to invalid IL or missing references)
				Vector3 closestPoint;
				float alongRay;
				if ((Object)(object)_unit == (Object)null || (Object)(object)_unit.data == (Object)null || _unit.data.Dead)
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				}
				else if (PossessionCrosshairAim.TryGetClosestPointOnUnitToRay(_unit, _aimRay, out closestPoint, out alongRay))
				{
					ApplyPosition(closestPoint);
				}
				else if ((Object)(object)_unit.data.mainRig != (Object)null)
				{
					ApplyPosition(_unit.data.mainRig.position);
				}
			}

			private void ApplyPosition(Vector3 position)
			{
				//IL_0006: 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_005b: 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)
				((Component)this).transform.position = position;
				_rig.position = position;
				_rig.velocity = (((Object)(object)_unit?.data?.mainRig != (Object)null) ? _unit.data.mainRig.velocity : Vector3.zero);
			}
		}

		private static readonly FieldInfo ShootPositionField = AccessTools.Field(typeof(RangeWeapon), "shootPosition");

		private static readonly FieldInfo ObjectToSpawnField = AccessTools.Field(typeof(RangeWeapon), "objectToSpawn");

		private static readonly Dictionary<MoveTransform, Vector3> PendingWorldLaunches = new Dictionary<MoveTransform, Vector3>();

		private static readonly Dictionary<RangeWeapon, bool> VolleyProjectilePatchActive = new Dictionary<RangeWeapon, bool>();

		private static readonly Dictionary<RangeWeapon, FrameAimCacheEntry> FrameAimCache = new Dictionary<RangeWeapon, FrameAimCacheEntry>();

		internal static bool TryGetCrosshairAimPoint(float maxDistance, out Vector3 aimPoint)
		{
			PossessionCrosshairAim.AimTarget target;
			return PossessionCrosshairAim.TryGetCrosshairAimPoint(maxDistance, out aimPoint, out target, allowSoftTargets: true);
		}

		internal static bool TryApplyToSpawnedProjectile(RangeWeapon weapon, GameObject spawnedObject, Vector3 spawnDirection)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return TryApplyToSpawnedProjectile(weapon, spawnedObject, spawnDirection, Vector3.zero, null);
		}

		internal static bool ShouldApplyCrosshairProjectileCorrection(RangeWeapon weapon)
		{
			return ShouldApplyCrosshairProjectileAim(weapon);
		}

		internal static bool ShouldUseCrosshairRayVolley(RangeWeapon weapon)
		{
			if ((Object)(object)weapon != (Object)null && ShouldApplyCrosshairProjectileAim(weapon))
			{
				return AimExclusionStore.ShouldUseVolleySpread(((Weapon)weapon).connectedData);
			}
			return false;
		}

		internal static void PrepareTightVolleyProjectileBeforeBallistic(RangeWeapon weapon, GameObject spawnedObject)
		{
		}

		internal static void FinalizeProjectileAim(RangeWeapon weapon, GameObject spawnedObject, Vector3 spawnDir, Rigidbody targetRig, bool ballisticApplied)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (ShouldRemoveAimSpread(weapon))
			{
				ZeroProjectileSpreadFields(spawnedObject);
				if (!ballisticApplied)
				{
					AlignProjectileToCrosshair(weapon, spawnedObject, spawnDir);
				}
			}
		}

		internal static bool ShouldRemoveAimSpread(RangeWeapon weapon)
		{
			if ((Object)(object)weapon == (Object)null || ShouldUseCrosshairRayVolley(weapon))
			{
				return false;
			}
			if (!FirstPersonFreeAimConfig.Enabled || !PossessionFreeAimLogic.IsPossessedUnit(((Weapon)weapon).connectedData))
			{
				return false;
			}
			return AimExclusionStore.ShouldUseCrosshairAim(((Weapon)weapon).connectedData);
		}

		internal static bool TryApplyToSpawnedProjectile(RangeWeapon weapon, GameObject spawnedObject, Vector3 spawnDirection, Vector3 directionToTarget, Rigidbody targetRig)
		{
			//IL_0032: 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)
			if (!FirstPersonFreeAimConfig.Enabled || (Object)(object)weapon == (Object)null || (Object)(object)spawnedObject == (Object)null || !ShouldApplyCrosshairProjectileCorrection(weapon))
			{
				return false;
			}
			if (ShouldSkipBallisticCorrection(weapon, spawnedObject, targetRig))
			{
				return false;
			}
			return TryApplyMoveTransformBallistic(weapon, spawnedObject, spawnDirection, directionToTarget);
		}

		private static bool TryApplyMoveTransformBallistic(RangeWeapon weapon, GameObject spawnedObject, Vector3 spawnDirection, Vector3 directionToTarget)
		{
			//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_0029: 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_002b: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			MoveTransform componentInChildren = spawnedObject.GetComponentInChildren<MoveTransform>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return false;
			}
			if (!TryGetLiveCrosshairAim(weapon, out var aimPoint, out var aimDirection, out var aimTarget))
			{
				return false;
			}
			Vector3 shootOrigin = GetShootOrigin(weapon);
			aimDirection = aimPoint - shootOrigin;
			if (((Vector3)(ref aimDirection)).sqrMagnitude < 0.25f)
			{
				return false;
			}
			float preferredSpeed = GetPreferredSpeed(componentInChildren);
			bool flag = preferredSpeed <= Mathf.Max(0.1f, 8f) && aimTarget.IsPredictive && (Object)(object)aimTarget.MainRig != (Object)null;
			bool flag2 = false;
			int frameCount = Time.frameCount;
			Vector3 launchVelocity;
			if ((Object)(object)weapon != (Object)null && FrameAimCache.TryGetValue(weapon, out var value) && value.Frame == frameCount && value.LaunchSolved && Mathf.Abs(value.PreferredSpeed - preferredSpeed) < 0.01f)
			{
				launchVelocity = value.LaunchVelocity;
				flag2 = ((Vector3)(ref launchVelocity)).sqrMagnitude > 0.0001f;
			}
			else
			{
				flag2 = (flag ? TrySolvePredictiveLaunchVelocity(shootOrigin, aimPoint, aimTarget, componentInChildren.gravity, preferredSpeed, out launchVelocity) : TrySolveLaunchVelocity(shootOrigin, aimPoint, componentInChildren.gravity, preferredSpeed, out launchVelocity));
				if (flag2 && (Object)(object)weapon != (Object)null)
				{
					if (FrameAimCache.TryGetValue(weapon, out value) && value.Frame == frameCount)
					{
						value.LaunchSolved = true;
						value.LaunchVelocity = launchVelocity;
						value.PreferredSpeed = preferredSpeed;
					}
					else
					{
						FrameAimCache[weapon] = new FrameAimCacheEntry
						{
							Frame = frameCount,
							AimPoint = aimPoint,
							LaunchSolved = true,
							LaunchVelocity = launchVelocity,
							PreferredSpeed = preferredSpeed
						};
					}
				}
			}
			if (!flag2)
			{
				return false;
			}
			ApplyLaunchToProjectile(weapon, spawnedObject, componentInChildren, launchVelocity, spawnDirection, directionToTarget, ShouldRemoveAimSpread(weapon));
			return true;
		}

		internal static void AdjustAttackForSpecialRangeWeapon(RangeWeapon weapon, ref Rigidbody targetRig, ref Vector3 forcedDirection)
		{
			//IL_0037: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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_0090: 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)
			if (!FirstPersonFreeAimConfig.Enabled || (Object)(object)weapon == (Object)null || !PossessionFreeAimLogic.IsPossessedUnit(((Weapon)weapon).connectedData) || !AimExclusionStore.ShouldUseCrosshairAim(((Weapon)weapon).connectedData) || !PossessionFreeAimLogic.TryGetCameraAim(out var aim))
			{
				return;
			}
			forcedDirection = aim;
			PossessionCrosshairAim.AimTarget aimTarget;
			Vector3 aimPoint2;
			if (ShouldUseCrosshairRayVolley(weapon))
			{
				if (TryGetLiveCrosshairAim(weapon, out var _, out var aimDirection, out aimTarget))
				{
					forcedDirection = aimDirection;
				}
			}
			else if (PossessionCrosshairAim.TryGetCrosshairAimPoint(PossessionCrosshairAim.GetAimDistanceForWeapon(weapon), out aimPoint2, out aimTarget, allowSoftTargets: true))
			{
				Vector3 shootOrigin = GetShootOrigin(weapon);
				Vector3 val = aimPoint2 - shootOrigin;
				if (((Vector3)(ref val)).sqrMagnitude > 0.01f)
				{
					forcedDirection = ((Vector3)(ref val)).normalized;
				}
			}
		}

		internal static bool TryBuildCrosshairRayAim(RangeWeapon weapon, out Vector3 aimPoint, out Vector3 aimDirection, bool allowSoftTargets = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			aimPoint = default(Vector3);
			aimDirection = default(Vector3);
			if ((Object)(object)weapon == (Object)null || !PossessionFreeAimLogic.IsPossessedUnit(((Weapon)weapon).connectedData))
			{
				return false;
			}
			if (!PossessionFreeAimLogic.TryGetCameraAim(out var aim, out var _))
			{
				return false;
			}
			if (!PossessionCrosshairAim.TryGetPossessionCamera(out var camera, out var _))
			{
				return false;
			}
			Vector3 shootOrigin = GetShootOrigin(weapon);
			float aimDistanceForWeapon = PossessionCrosshairAim.GetAimDistanceForWeapon(weapon);
			aimDirection = ((((Vector3)(ref aim)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref aim)).normalized : ((Component)camera).transform.forward);
			if (PossessionCrosshairAim.TryGetCrosshairAimPoint(aimDistanceForWeapon, out aimPoint, out var target, allowSoftTargets))
			{
				if (allowSoftTargets && (Object)(object)target.MainRig != (Object)null)
				{
					Ray ray = default(Ray);
					((Ray)(ref ray))..ctor(((Component)camera).transform.position, aimDirection);
					aimPoint = PossessionCrosshairAim.ProjectOntoCrosshairRay(ray, aimPoint);
				}
				Vector3 val = aimPoint - shootOrigin;
				if (((Vector3)(ref val)).sqrMagnitude > 0.01f)
				{
					aimDirection = ((Vector3)(ref val)).normalized;
				}
				return true;
			}
			aimPoint = shootOrigin + aimDirection * Mathf.Max(4f, aimDistanceForWeapon);
			return true;
		}

		internal static bool TryBuildCrosshairAim(RangeWeapon weapon, out Vector3 aimPoint, out Vector3 aimDirection)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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)
			//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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00c8: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: 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)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_0151: 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_015b: Unknown result type (might be due to invalid IL or missing references)
			aimPoint = default(Vector3);
			aimDirection = default(Vector3);
			if ((Object)(object)weapon == (Object)null || !PossessionFreeAimLogic.IsPossessedUnit(((Weapon)weapon).connectedData))
			{
				return false;
			}
			if (!PossessionFreeAimLogic.TryGetCameraAim(out var aim, out var _))
			{
				return false;
			}
			if (!PossessionCrosshairAim.TryGetPossessionCamera(out var _, out var possess) || (Object)(object)possess == (Object)null || !possess.IsPossessing)
			{
				return false;
			}
			Vector3 shootOrigin = GetShootOrigin(weapon);
			float aimDistanceForWeapon = PossessionCrosshairAim.GetAimDistanceForWeapon(weapon);
			if (!PossessionCrosshairAim.TryGetCrosshairAimPoint(aimDistanceForWeapon, out aimPoint, out var _, allowSoftTargets: true))
			{
				aimPoint = shootOrigin + aim * Mathf.Max(4f, aimDistanceForWeapon * 0.35f);
			}
			Vector3 val = aimPoint - shootOrigin;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.75f)
			{
				aimPoint = shootOrigin + aim * Mathf.Max(4f, aimDistanceForWeapon * 0.35f);
				val = aimPoint - shootOrigin;
				magnitude = ((Vector3)(ref val)).magnitude;
			}
			aimDirection = ((magnitude > 0.01f) ? (val / magnitude) : ((((Vector3)(ref aim)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref aim)).normalized : Vector3.forward));
			if (Vector3.Dot(aimPoint - shootOrigin, aimDirection) < 0f)
			{
				aimPoint = shootOrigin + aimDirection * Mathf.Max(magnitude, 4f);
			}
			return true;
		}

		internal static bool TryGetLiveCrosshairAim(RangeWeapon weapon, out Vector3 aimPoint, out Vector3 aimDirection, out PossessionCrosshairAim.AimTarget aimTarget)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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)
			aimPoint = default(Vector3);
			aimDirection = default(Vector3);
			aimTarget = default(PossessionCrosshairAim.AimTarget);
			int frameCount = Time.frameCount;
			if ((Object)(object)weapon != (Object)null && FrameAimCache.TryGetValue(weapon, out var value) && value.Frame == frameCount)
			{
				aimPoint = value.AimPoint;
				aimDirection = value.AimDirection;
				aimTarget = value.AimTarget;
				return true;
			}
			float aimDistanceForWeapon = PossessionCrosshairAim.GetAimDistanceForWeapon(weapon);
			if (!TryBuildCrosshairAim(weapon, out aimPoint, out aimDirection))
			{
				return false;
			}
			PossessionCrosshairAim.TryGetCrosshairAimPoint(aimDistanceForWeapon, out var _, out aimTarget, allowSoftTargets: true);
			if ((Object)(object)weapon != (Object)null)
			{
				FrameAimCache[weapon] = new FrameAimCacheEntry
				{
					Frame = frameCount,
					AimPoint = aimPoint,
					AimDirection = aimDirection,
					AimTarget = aimTarget
				};
			}
			return true;
		}

		internal static bool TryReplaceLockOnTargetWithCrosshair(RangeWeapon weapon, ref Rigidbody targetRig)
		{
			//IL_002a: 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)
			if (!ShouldApplyCrosshairProjectileCorrection(weapon) || (Object)(object)targetRig == (Object)null)
			{
				return false;
			}
			if (!TryGetHomingSurfaceAimPoint(weapon, targetRig, out var surfacePoint, out var _, out var targetUnit, out var aimRay))
			{
				return false;
			}
			targetRig = CreateHomingTargetRig(targetUnit, aimRay, surfacePoint);
			return (Object)(object)targetRig != (Object)null;
		}

		internal static bool ShouldApplyCrosshairHomingForSpawner(DataHandler data)
		{
			if (!FirstPersonFreeAimConfig.Enabled || (Object)(object)data == (Object)null)
			{
				return false;
			}
			if (!PossessionFreeAimLogic.IsPossessedUnit(data))
			{
				return false;
			}
			if (AimExclusionStore.IsUnitExcluded(data))
			{
				return false;
			}
			return AimExclusionStore.ShouldUseCrosshairAim(data);
		}

		internal static bool TryGetHomingSurfaceAimPoint(RangeWeapon weapon, Rigidbody vanillaTargetRig, out Vector3 surfacePoint, out Vector3 aimDirection, out Unit targetUnit, out Ray aimRay)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0039: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_007f: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			surfacePoint = default(Vector3);
			aimDirection = default(Vector3);
			targetUnit = null;
			aimRay = default(Ray);
			if (!ShouldApplyCrosshairProjectileCorrection(weapon))
			{
				return false;
			}
			if (!PossessionCrosshairAim.TryGetPossessionCamera(out var camera, out var possess))
			{
				return false;
			}
			aimRay = new Ray(((Component)camera).transform.position, ((Component)camera).transform.forward);
			float aimDistanceForWeapon = PossessionCrosshairAim.GetAimDistanceForWeapon(weapon);
			targetUnit = ResolveHomingTargetUnit(possess, camera, vanillaTargetRig, aimDistanceForWeapon, aimRay);
			if ((Object)(object)targetUnit == (Object)null)
			{
				return false;
			}
			if (!PossessionCrosshairAim.TryGetClosestPointOnUnitToRay(targetUnit, aimRay, out surfacePoint, out var _))
			{
				if ((Object)(object)targetUnit.data?.mainRig == (Object)null)
				{
					return false;
				}
				surfacePoint = targetUnit.data.mainRig.position;
			}
			Vector3 shootOrigin = GetShootOrigin(weapon);
			Vector3 val = surfacePoint - shootOrigin;
			aimDirection = ((((Vector3)(ref val)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref val)).normalized : ((Ray)(ref aimRay)).direction);
			return true;
		}

		private static Unit ResolveHomingTargetUnit(CameraAbilityPossess possess, Camera camera, Rigidbody vanillaTargetRig, float maxDistance, Ray aimRay)
		{
			if ((Object)(object)vanillaTargetRig != (Object)null)
			{
				Unit componentInParent = ((Component)vanillaTargetRig).GetComponentInParent<Unit>();
				if ((Object)(object)componentInParent != (Object)null && PossessionCrosshairAim.IsValidTargetUnit(possess, componentInParent))
				{
					return componentInParent;
				}
			}
			if (PossessionCrosshairAim.TryGetCrosshairAimPoint(maxDistance, out var _, out var target, allowSoftTargets: true, allowFrameCache: false) && (Object)(object)target.MainRig != (Object)null)
			{
				Unit componentInParent2 = ((Component)target.MainRig).GetComponentInParent<Unit>();
				if ((Object)(object)componentInParent2 != (Object)null)
				{
					return componentInParent2;
				}
			}
			Unit[] unitsOnCrosshairRay = PossessionUnitTargetQuery.GetUnitsOnCrosshairRay(possess, camera, maxDistance);
			if (unitsOnCrosshairRay != null)
			{
				foreach (Unit val in unitsOnCrosshairRay)
				{
					if ((Object)(object)val != (Object)null && PossessionCrosshairAim.IsValidTargetUnit(possess, val))
					{
						return val;
					}
				}
			}
			if (PossessionUnitTargetQuery.TryGetPrimaryRayTarget(possess, camera, 5f, out var unit, out var _) && (Object)(object)unit != (Object)null)
			{
				return unit;
			}
			return null;
		}

		internal static bool TryApplyHomingTarget(RangeWeapon weapon, ref Rigidbody targetRig)
		{
			//IL_002a: 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)
			if (ShouldUseCrosshairRayVolley(weapon))
			{
				return false;
			}
			if (!ShouldApplyCrosshairProjectileCorrection(weapon))
			{
				return false;
			}
			if (!TryGetHomingSurfaceAimPoint(weapon, targetRig, out var surfacePoint, out var _, out var targetUnit, out var aimRay))
			{
				return false;
			}
			targetRig = CreateHomingTargetRig(targetUnit, aimRay, surfacePoint);
			return (Object)(object)targetRig != (Object)null;
		}

		internal static bool IsHomingTrackerRig(Rigidbody rig)
		{
			if ((Object)(object)rig != (Object)null)
			{
				return (Object)(object)((Component)rig).GetComponent<UnitSurfaceHomingTarget>() != (Object)null;
			}
			return false;
		}

		internal static void ReleaseHomingTracker(Rigidbody rig)
		{
			if (!((Object)(object)rig == (Object)null))
			{
				UnitSurfaceHomingTarget component = ((Component)rig).GetComponent<UnitSurfaceHomingTarget>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)component).gameObject);
				}
			}
		}

		private static Rigidbody CreateHomingTargetRig(Unit targetUnit, Ray aimRay, Vector3 surfacePoint)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)targetUnit == (Object)null)
			{
				return null;
			}
			return UnitSurfaceHomingTarget.Create(targetUnit, aimRay, surfacePoint);
		}

		internal static bool ShouldApplyCrosshairProjectileAim(RangeWeapon weapon)
		{
			if (!FirstPersonFreeAimConfig.Enabled || (Object)(object)weapon == (Object)null || !PossessionFreeAimLogic.IsPossessedUnit(((Weapon)weapon).connectedData))
			{
				return false;
			}
			return AimExclusionStore.ShouldUseCrosshairAim(((Weapon)weapon).connectedData);
		}

		internal static bool ShouldRunPossessionProjectilePatches(RangeWeapon weapon)
		{
			if ((Object)(object)weapon == (Object)null)
			{
				return false;
			}
			if (VolleyProjectilePatchActive.TryGetValue(weapon, out var value))
			{
				return value;
			}
			return ShouldApplyCrosshairProjectileAim(weapon);
		}

		internal static void BeginVolleyProjectilePatches(RangeWeapon weapon)
		{
			if (!((Object)(object)weapon == (Object)null))
			{
				VolleyProjectilePatchActive[weapon] = ShouldApplyCrosshairProjectileAim(weapon);
			}
		}

		internal static void EndVolleyProjectilePatches(RangeWeapon weapon)
		{
			if ((Object)(object)weapon != (Object)null)
			{
				VolleyProjectilePatchActive.Remove(weapon);
			}
		}

		internal static void ClearFrameAimCache(RangeWeapon weapon)
		{
			if ((Object)(object)weapon != (Object)null)
			{
				FrameAimCache.Remove(weapon);
			}
		}

		internal static bool TryOverrideSpawnDirection(RangeWeapon weapon, ref Vector3 spawnDirection)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_0057: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldApplyCrosshairProjectileAim(weapon))
			{
				return false;
			}
			if (!TryGetLiveCrosshairAim(weapon, out var aimPoint, out var aimDirection, out var _))
			{
				return false;
			}
			spawnDirection = aimDirection;
			if (ShouldUseCrosshairRayVolley(weapon) && PossessionProjectileAim.TryGetVolleyAngularSpread(weapon, out var angularSpread) && angularSpread > 0.01f)
			{
				aimPoint = aimDirection + Random.insideUnitSphere * angularSpread * 0.01f;
				spawnDirection = ((Vector3)(ref aimPoint)).normalized;
			}
			return true;
		}

		internal static bool TryOverrideSpawnPosition(RangeWeapon weapon, ref Vector3 spawnPosition)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_003d: 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_008f: 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)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldApplyCrosshairProjectileAim(weapon))
			{
				return false;
			}
			if ((int)weapon.spawnPosition != 1)
			{
				return false;
			}
			object? obj = ShootPositionField?.GetValue(weapon);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			if (val == null || (Object)(object)val == (Object)null)
			{
				return false;
			}
			spawnPosition = val.position;
			if ((Object)(object)((Weapon)weapon).connectedData?.characterForwardObject != (Object)null)
			{
				spawnPosition += ((Weapon)weapon).connectedData.characterForwardObject.forward * weapon.characterForwardOffset;
			}
			spawnPosition += weapon.positionOffset;
			return true;
		}

		internal static void TryPrepareProjectileStatsForPossession(RangeWeapon weapon, ref Rigidbody targetRig, ref Vector3 directionToTarget, ref Vector3 targetRigPosition, ref Vector3 targetRigVelocity)
		{
			TryPrepareCrosshairProjectileStats(weapon, ref targetRig, ref directionToTarget, ref targetRigPosition, ref targetRigVelocity);
		}

		internal static bool TryPrepareCrosshairProjectileStats(RangeWeapon weapon, ref Rigidbody targetRig, ref Vector3 directionToTarget, ref Vector3 targetRigPosition, ref Vector3 targetRigVelocity)
		{
			//IL_002f: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldApplyCrosshairProjectileCorrection(weapon))
			{
				return false;
			}
			if (TryPrepareRayVolleyProjectileStats(weapon, ref targetRig, ref directionToTarget, ref targetRigPosition, ref targetRigVelocity))
			{
				return true;
			}
			if (!TryGetHomingSurfaceAimPoint(weapon, targetRig, out var surfacePoint, out var aimDirection, out var targetUnit, out var aimRay))
			{
				return false;
			}
			targetRig = CreateHomingTargetRig(targetUnit, aimRay, surfacePoint);
			if ((Object)(object)targetRig == (Object)null)
			{
				return false;
			}
			targetRigPosition = surfacePoint;
			targetRigVelocity = (((Object)(object)targetUnit?.data?.mainRig != (Object)null) ? targetUnit.data.mainRig.velocity : Vector3.zero);
			directionToTarget = aimDirection;
			return true;
		}

		private static bool TryPrepareRayVolleyProjectileStats(RangeWeapon weapon, ref Rigidbody targetRig, ref Vector3 directionToTarget, ref Vector3 targetRigPosition, ref Vector3 targetRigVelocity)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_002b: 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)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldUseCrosshairRayVolley(weapon))
			{
				return false;
			}
			if (!TryGetLiveCrosshairAim(weapon, out var aimPoint, out var aimDirection, out var _))
			{
				return false;
			}
			targetRig = null;
			targetRigVelocity = Vector3.zero;
			targetRigPosition = aimPoint;
			directionToTarget = aimDirection;
			return true;
		}

		internal static void EnforceCrosshairLaunch(RangeWeapon weapon, GameObject spawnedObject, Vector3 fallbackSpawnDir, bool ballisticApplied)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!ballisticApplied && !((Object)(object)spawnedObject == (Object)null) && ShouldApplyCrosshairProjectileCorrection(weapon))
			{
				AlignProjectileToCrosshair(weapon, spawnedObject, fallbackSpawnDir);
			}
		}

		internal static void StripShooterVelocityInheritance(RangeWeapon weapon, GameObject spawnedObject)
		{
			//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_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)
			if (!((Object)(object)spawnedObject == (Object)null) && ShouldApplyCrosshairProjectileCorrection(weapon))
			{
				MoveTransform componentInChildren = spawnedObject.GetComponentInChildren<MoveTransform>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.worldImpulse = Vector3.zero;
					componentInChildren.velocity = Vector3.zero;
				}
			}
		}

		internal static void DetachCrosshairProjectile(RangeWeapon weapon, GameObject spawnedObject)
		{
			if (!((Object)(object)spawnedObject == (Object)null) && ShouldApplyCrosshairProjectileCorrection(weapon) && (Object)(object)spawnedObject.transform.parent != (Object)null)
			{
				spawnedObject.transform.SetParent((Transform)null, true);
			}
		}

		internal static void ApplyWorldSpaceLaunch(MoveTransform move, Vector3 worldVelocity)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_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_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_007b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)move == (Object)null))
			{
				move.worldImpulse = Vector3.zero;
				if (((Vector3)(ref worldVelocity)).sqrMagnitude > 0.0001f)
				{
					move.velocity = worldVelocity;
					move.selfImpulse = new Vector3(0f, 0f, ((Vector3)(ref worldVelocity)).magnitude);
					((Component)move).transform.rotation = Quaternion.LookRotation(((Vector3)(ref worldVelocity)).normalized);
				}
				else
				{
					move.velocity = Vector3.zero;
					move.selfImpulse = Vector3.zero;
				}
				PendingWorldLaunches[move] = worldVelocity;
			}
		}

		internal static void FinalizeWorldLaunchAfterInit(MoveTransform move)
		{
			//IL_0026: 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)
			//IL_0031: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)move == (Object)null) && PendingWorldLaunches.TryGetValue(move, out var value))
			{
				PendingWorldLaunches.Remove(move);
				move.worldImpulse = Vector3.zero;
				move.velocity = value;
				if (((Vector3)(ref value)).sqrMagnitude > 0.0001f)
				{
					move.selfImpulse = new Vector3(0f, 0f, ((Vector3)(ref value)).magnitude);
					((Component)move).transform.rotation = Quaternion.LookRotation(((Vector3)(ref value)).normalized);
				}
				else
				{
					move.selfImpulse = Vector3.zero;
				}
			}
		}

		internal static Vector3 GetShootOrigin(RangeWeapon weapon)
		{
			//IL_0031: 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)
			object? obj = ShootPositionField?.GetValue(weapon);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			if (val != null && (Object)(object)val != (Object)null)
			{
				return val.position;
			}
			return ((Component)weapon).transform.position;
		}

		private static float GetPreferredSpeed(MoveTransform move)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Vector3 selfImpulse = move.selfImpulse;
			float num = ((Vector3)(ref selfImpulse)).magnitude;
			if (num < 0.5f)
			{
				num = Mathf.Abs(selfImpulse.z);
			}
			return Mathf.Max(num, 3f);
		}

		private static bool TryGetPreciseAimDirection(RangeWeapon weapon, out Vector3 direction)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			direction = default(Vector3);
			Vector3 aimPoint;
			PossessionCrosshairAim.AimTarget aimTarget;
			return TryGetLiveCrosshairAim(weapon, out aimPoint, out direction, out aimTarget);
		}

		private static void ZeroProjectileSpreadFields(GameObject spawnedObject)
		{
			if (!((Object)(object)spawnedObject == (Object)null))
			{
				MoveTransform componentInChildren = spawnedObject.GetComponentInChildren<MoveTransform>();
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					componentInChildren.projectileSpeedSpread = 0f;
					componentInChildren.sprea = 0f;
					componentInChildren.randomVelocitySpread = 0f;
				}
			}
		}

		private static void SyncProjectileFacingToLaunch(GameObject spawnedObject)
		{
			//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_0040: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)spawnedObject == (Object)null)
			{
				return;
			}
			MoveTransform componentInChildren = spawnedObject.GetComponentInChildren<MoveTransform>();
			if (!((Object)(object)componentInChildren == (Object)null) && !(((Vector3)(ref componentInChildren.velocity)).sqrMagnitude < 0.0001f))
			{
				Vector3 normalized = ((Vector3)(ref componentInChildren.velocity)).normalized;
				spawnedObject.transform.rotation = Quaternion.LookRotation(normalized);
				Compensation[] componentsInChildren = spawnedObject.GetComponentsInChildren<Compensation>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).transform.rotation = Quaternion.LookRotation(normalized);
				}
			}
		}

		private static bool TryGetCrosshairLaunchDirection(RangeWeapon weapon, Vector3 spawnDir, out Vector3 aimDirection)
		{
			//IL_0001: 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)
			aimDirection = default(Vector3);
			if (ShouldApplyCrosshairProjectileCorrection(weapon) && PossessionFreeAimLogic.TryGetCameraAim(out aimDirection) && ((Vector3)(ref aimDirection)).sqrMagnitude > 0.0001f)
			{
				((Vector3)(ref aimDirection)).Normalize();
				return true;
			}
			if (TryGetLiveCrosshairAim(weapon, out var _, out aimDirection, out var _) && ((Vector3)(ref aimDirection)).sqrMagnitude > 0.0001f)
			{
				((Vector3)(ref aimDirection)).Normalize();
				return true;
			}
			if (((Vector3)(ref spawnDir)).sqrMagnitude < 0.0001f)
			{
				return false;
			}
			aimDirection = ((Vector3)(ref spawnDir)).normalized;
			return true;
		}

		private static void AlignProjectileToCrosshair(RangeWeapon weapon, GameObject spawnedObject, Vector3 spawnDir)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_0039: 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_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_005f: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_00e7: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)spawnedObject == (Object)null || !TryGetCrosshairLaunchDirection(weapon, spawnDir, out var aimDirection))
			{
				return;
			}
			bool flag = ShouldRemoveAimSpread(weapon);
			Vector3 val;
			if (!flag && ((Vector3)(ref spawnDir)).sqrMagnitude > 0.0001f)
			{
				val = spawnedObject.transform.forward;
				if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
				{
					Vector3 normalized = ((Vector3)(ref spawnDir)).normalized;
					val = spawnedObject.transform.forward;
					aimDirection = Quaternion.FromToRotation(normalized, ((Vector3)(ref val)).normalized) * aimDirection;
					if (((Vector3)(ref aimDirection)).sqrMagnitude < 0.0001f)
					{
						return;
					}
					((Vector3)(ref aimDirection)).Normalize();
				}
			}
			spawnedObject.transform.rotation = Quaternion.LookRotation(aimDirection);
			MoveTransform componentInChildren = spawnedObject.GetComponentInChildren<MoveTransform>();
			float num = 3f;
			if ((Object)(object)componentInChildren != (Object)null)
			{
				if (flag)
				{
					ZeroProjectileSpreadFields(spawnedObject);
				}
				num = Mathf.Max(Mathf.Abs(componentInChildren.selfImpulse.z), ((Vector3)(ref componentInChildren.selfImpulse)).magnitude);
				if (num < 0.5f)
				{
					num = GetPreferredSpeed(componentInChildren);
				}
				ApplyWorldSpaceLaunch(componentInChildren, aimDirection * num);
			}
			else if (((Vector3)(ref spawnDir)).sqrMagnitude > 0.0001f)
			{
				num = Mathf.Max(((Vector3)(ref spawnDir)).magnitude, 3f);
			}
			Compensation[] componentsInChildren = spawnedObject.GetComponentsInChildren<Compensation>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Component)componentsInChildren[i]).transform.rotation = Quaternion.LookRotation(aimDirection);
			}
			Rigidbody[] componentsInChildren2 = spawnedObject.GetComponentsInChildren<Rigidbody>();
			foreach (Rigidbody obj in componentsInChildren2)
			{
				val = obj.velocity;
				float num2 = ((Vector3)(ref val)).magnitude;
				if (num2 < 0.5f)
				{
					num2 = num;
				}
				obj.velocity = aimDirection * num2;
			}
		}

		private static bool ShouldSkipBallisticCorrection(RangeWeapon weapon, GameObject spawnedObject, Rigidbody targetRig)
		{
			object? obj = ObjectToSpawnField?.GetValue(weapon);
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val.GetComponentInChildren<MoveTransform>() == (Object)null && (Object)(object)spawnedObject != (Object)null && (Object)(object)spawnedObject.GetComponentInChildren<MoveTransform>() == (Object)null)
			{
				return true;
			}
			return false;
		}

		private static bool TrySolvePredictiveLaunchVelocity(Vector3 origin, Vector3 crosshairAimPoint, PossessionCrosshairAim.AimTarget target, float gravity, float preferredSpeed, out Vector3 launchVelocity)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_0097: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (!target.IsPredictive || (Object)(object)target.MainRig == (Object)null)
			{
				return TrySolveLaunchVelocity(origin, crosshairAimPoint, gravity, preferredSpeed, out launchVelocity);
			}
			Vector3 val = ClampTargetVelocity(target.MainRig.velocity);
			launchVelocity = default(Vector3);
			float num = Mathf.Clamp(Vector3.Distance(origin, crosshairAimPoint) / Mathf.Max(preferredSpeed, 1f), 0.08f, 4f);
			for (int i = 0; i < Mathf.Max(1, 4); i++)
			{
				Vector3 aimPoint = crosshairAimPoint + val * num * 1f;
				if (!TrySolveLaunchVelocity(origin, aimPoint, gravity, preferredSpeed, out var launchVelocity2))
				{
					break;
				}
				launchVelocity = launchVelocity2;
				num = Mathf.Clamp(EstimateFlightTime(origin, aimPoint, launchVelocity), 0.08f, 4f);
			}
			if (!(((Vector3)(ref launchVelocity)).sqrMagnitude > 0.01f))
			{
				return TrySolveLaunchVelocity(origin, crosshairAimPoint, gravity, preferredSpeed, out launchVelocity);
			}
			return true;
		}

		private static Vector3 ClampTargetVelocity(Vector3 velocity)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			velocity = Vector3.ClampMagnitude(velocity, 12f);
			velocity.y *= 0.5f;
			return velocity;
		}

		private static float EstimateFlightTime(Vector3 origin, Vector3 aimPoint, Vector3 launchVelocity)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_001a: 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_0028: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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)
			Vector2 val = new Vector2(aimPoint.x - origin.x, aimPoint.z - origin.z);
			float magnitude = ((Vector2)(ref val)).magnitude;
			val = new Vector2(launchVelocity.x, launchVelocity.z);
			float magnitude2 = ((Vector2)(ref val)).magnitude;
			if (magnitude2 > 0.1f)
			{
				return magnitude / magnitude2;
			}
			return Vector3.Distance(origin, aimPoint) / Mathf.Max(((Vector3)(ref launchVelocity)).magnitude, 1f);
		}

		internal static bool TrySolveLaunchVelocity(Vector3 origin, Vector3 aimPoint, float gravity, float preferredSpeed, out Vector3 launchVelocity)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_003b: 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_0046: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: 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_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: 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_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			launchVelocity = default(Vector3);
			Vector3 val = aimPoint - origin;
			if (gravity < 0.05f)
			{
				launchVelocity = ((Vector3)(ref val)).normalized * preferredSpeed;
				return ((Vector3)(ref launchVelocity)).sqrMagnitude > 0.01f;
			}
			Vector3 val2 = Vector3.down * gravity;
			float num = preferredSpeed * 0.4f;
			float num2 = preferredSpeed * 2.75f;
			Vector2 val3 = new Vector2(val.x, val.z);
			float num3 = Mathf.Clamp(((Vector2)(ref val3)).magnitude / Mathf.Max(preferredSpeed, 1f), 0.12f, 3.5f);
			float num4 = float.PositiveInfinity;
			Vector3 val4 = Vector3.zero;
			float num5 = Mathf.Max(0.08f, num3 * 0.35f);
			float num6 = Mathf.Max(num5 + 0.05f, num3 * 2.75f);
			for (float num7 = num5; num7 <= num6; num7 += 0.025f)
			{
				Vector3 val5 = (val - 0.5f * val2 * num7 * num7) / num7;
				float magnitude = ((Vector3)(ref val5)).magnitude;
				if (!(magnitude < num) && !(magnitude > num2))
				{
					Vector3 val6 = origin + val5 * num7 + 0.5f * val2 * num7 * num7 - aimPoint;
					float sqrMagnitude = ((Vector3)(ref val6)).sqrMagnitude;
					float num8 = Mathf.Abs(magnitude - preferredSpeed) * 0.02f;
					sqrMagnitude += num8;
					if (sqrMagnitude < num4)
					{
						num4 = sqrMagnitude;
						val4 = val5;
					}
				}
			}
			if (num4 > 2f && ((Vector3)(ref val4)).sqrMagnitude < 0.01f)
			{
				return false;
			}
			launchVelocity = val4;
			return ((Vector3)(ref launchVelocity)).sqrMagnitude > 0.01f;
		}

		private static void ApplyLaunchToProjectile(RangeWeapon weapon, GameObject spawnedObject, MoveTransform move, Vector3 launchVelocity, Vector3 fallbackDirection, Vector3 originalDirectionToTarget, bool removeSpread)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((((Vector3)(ref launchVelocity)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref launchVelocity)).normalized : ((Vector3)(ref fallbackDirection)).normalized);
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				return;
			}
			float num = ((Vector3)(ref launchVelocity)).magnitude;
			bool flag = (Object)(object)weapon != (Object)null && ShouldUseCrosshairRayVolley(weapon);
			if (!removeSpread)
			{
				Quaternion val2 = Quaternion.identity;
				Vector3 forward = spawnedObject.transform.forward;
				if (!flag && ((Vector3)(ref fallbackDirection)).sqrMagnitude > 0.0001f && ((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
				{
					val2 = Quaternion.FromToRotation(((Vector3)(ref fallbackDirection)).normalized, ((Vector3)(ref forward)).normalized);
				}
				val = val2 * val;
				if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
				{
					return;
				}
				((Vector3)(ref val)).Normalize();
				float num2 = move.projectileSpeedSpread;
				if (num2 <= 0.01f && (Object)(object)weapon != (Object)null && PossessionProjectileAim.TryGetVolleySpeedSpread(weapon, out var speedSpread))
				{
					num2 = speedSpread;
				}
				if (num2 > 0.01f)
				{
					num *= Random.Range(1f - num2 * 0.01f, 1f + num2 * 0.01f);
				}
				Vector3 val4;
				if (flag && PossessionProjectileAim.TryGetVolleyAngularSpread(weapon, out var angularSpread) && angularSpread > 0.01f)
				{
					Vector3 val3 = Random.insideUnitSphere * angularSpread * 0.01f;
					val4 = val + val3;
					val = ((Vector3)(ref val4)).normalized;
				}
				else if ((Object)(object)weapon != (Object)null && weapon.spread > 0.01f && val2 == Quaternion.identity && ((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
				{
					Vector3 val5 = Random.insideUnitSphere * weapon.spread * 0.01f;
					val4 = val + val5;
					val = ((Vector3)(ref val4)).normalized;
				}
			}
			ApplyWorldSpaceLaunch(move, val * num);
			Compensation componentInChildren = spawnedObject.GetComponentInChildren<Compensation>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Component)componentInChildren).transform.rotation = Quaternion.LookRotation(val);
			}
			AddForce component = spawnedObject.GetComponent<AddForce>();
			if ((Object)(object)component != (Object)null && ((Vector3)(ref component.force)).sqrMagnitude > 0.01f)
			{
				float num3 = ((component.force.z >= 0f) ? 1f : (-1f));
				component.force = new Vector3(component.force.x, component.force.y, num3 * num);
			}
		}
	}
	internal static class PossessionBallisticAimPatches
	{
		[HarmonyPrefix]
		internal static bool RangeWeapon_GetSpawnDirection_Prefix(RangeWeapon __instance, ref Vector3 __result, Vector3 directionToTarget, Rigidbody targetRig, Vector3 forcedDirection)
		{
			if (!PossessionBallisticAim.ShouldRunPossessionProjectilePatches(__instance))
			{
				return true;
			}
			if (!PossessionBallisticAim.TryOverrideSpawnDirection(__instance, ref __result))
			{
				return true;
			}
			return false;
		}

		[HarmonyPostfix]
		internal static void RangeWeapon_GetSpawnPosition_Postfix(RangeWeapon __instance, ref Vector3 __result)
		{
			if (PossessionBallisticAim.ShouldRunPossessionProjectilePatches(__instance))
			{
				PossessionBallisticAim.TryOverrideSpawnPosition(__instance, ref __result);
			}
		}

		[HarmonyPrefix]
		internal static void RangeWeapon_SetTeamHolder_Prefix(RangeWeapon __instance, ref Rigidbody targetRig)
		{
			PossessionBallisticAim.ShouldRunPossessionProjectilePatches(__instance);
		}

		[HarmonyPrefix]
		internal static void RangeWeapon_SetTargetableEffects_Prefix(RangeWeapon __instance, ref Rigidbody targetRig)
		{
			if (PossessionBallisticAim.ShouldRunPossessionProjectilePatches(__instance))
			{
				PossessionBallisticAim.TryApplyHomingTarget(__instance, ref targetRig);
			}
		}

		[HarmonyPrefix]
		internal static void RangeWeapon_SetProjectileStats_Prefix(RangeWeapon __instance, ref Rigidbody targetRig, ref Vector3 directionToTarget, ref Vector3 targetRigPosition, ref Vector3 targetRigVelocity)
		{
			if (PossessionBallisticAim.ShouldRunPossessionProjectilePatches(__instance))
			{
				PossessionBallisticAim.TryPrepareProjectileStatsForPossession(__instance, ref targetRig, ref directionToTarget, ref targetRigPosition, ref targetRigVelocity);
			}
		}

		[HarmonyPostfix]
		internal static void RangeWeapon_SetProjectileStats_Postfix(RangeWeapon __instance, GameObject spawnedObject, Vector3 spawnDir, Vector3 directionToTarget, Rigidbody targetRig)
		{
			//IL_0020: 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)
			if (PossessionBallisticAim.ShouldRunPossessionProjectilePatches(__instance))
			{
				PossessionBallisticAim.StripShooterVelocityInheritance(__instance, spawnedObject);
				PossessionBallisticAim.PrepareTightVolleyProjectileBeforeBallistic(__instance, spawnedObject);
				PossessionProjectileAim.TryCaptureSpreadFromSpawnedProjectile(__instance, spawnedObject);
				bool ballisticApplied = PossessionBallisticAim.TryApplyToSpawnedProjectile(__instance, spawnedObject, spawnDir, directionToTarget, targetRig);
				PossessionBallisticAim.FinalizeProjectileAim(__instance, spawnedObject, spawnDir, targetRig, ballisticApplied);
				PossessionBallisticAim.EnforceCrosshairLaunch(__instance, spawnedObject, spawnDir, ballisticApplied);
				PossessionBallisticAim.DetachCrosshairProjectile(__instance, spawnedObject);
				PossessionProjectileAim.CompleteProjectile(__instance);
			}
		}

		[HarmonyPostfix]
		internal static void MoveTransform_InitializeVelocity_Postfix(MoveTransform __instance)
		{
			PossessionBallisticAim.FinalizeWorldLaunchAfterInit(__instance);
		}
	}
	internal sealed class PossessionBattleDashToggle : MonoBehaviour
	{
		private const string DashSuffixMarker = " · Battle Dash ";

		private static readonly FieldInfo MainControlsPromptField = AccessTools.Field(typeof(CameraAbilityPossessUI), "mainControlsPrompt");

		private static readonly Color DashOnColor = new Color(0.85f, 1f, 0.85f, 0.98f);

		private static readonly Color DashOffColor = new Color(1f, 0.45f, 0.45f, 0.98f);

		private static readonly Color PromptDefaultColor = Color.white;

		private static string _cachedBasePrompt;

		private static Component _cachedPromptTmp;

		private static CameraAbilityPossessUI _cachedPromptUi;

		private void LateUpdate()
		{
			if (TryGetActiveDashContext(out var possess, out var data))
			{
				TryHandleHotkey(possess, data);
			}
		}

		internal static void UpdateCooldowns_Postfix(CameraAbilityPossessUI __instance)
		{
			if ((Object)(object)__instance == (Object)null || !__instance.UIActive)
			{
				return;
			}
			if (!BattleStateHelper.IsBattleActive())
			{
				ClearPrompt(__instance);
				return;
			}
			CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
			if ((Object)(object)possess == (Object)null || !possess.IsPossessing)
			{
				ClearPrompt(__instance);
			}
			else
			{
				UpdateMainControlsPrompt(__instance, possess.currentUnit?.data);
			}
		}

		internal static void UpdatePrompts_Postfix(CameraAbilityPossessUI __instance)
		{
			InvalidatePromptCache();
			if (!((Object)(object)__instance == (Object)null) && __instance.UIActive && BattleStateHelper.IsBattleActive())
			{
				CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
				if (!((Object)(object)possess == (Object)null) && possess.IsPossessing)
				{
					UpdateMainControlsPrompt(__instance, possess.currentUnit?.data);
				}
			}
		}

		private static bool TryGetActiveDashContext(out CameraAbilityPossess possess, out DataHandler data)
		{
			possess = null;
			data = null;
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures())
			{
				return false;
			}
			if (!BattleStateHelper.IsBattleActive())
			{
				return false;
			}
			possess = PossessionFreeAimLogic.GetPossess();
			if ((Object)(object)possess == (Object)null || !possess.IsPossessing)
			{
				return false;
			}
			data = possess.currentUnit?.data;
			return AimExclusionStore.ShouldShowBattleDashToggle(data);
		}

		private static void TryHandleHotkey(CameraAbilityPossess possess, DataHandler data)
		{
			if (!AimExclusionMenu.IsOpen && !IsPausedOrMatchOver(possess) && AimExclusionStore.WasBattleDashToggleKeyPressed())
			{
				BattleMeleeDashStore.Toggle(data);
				CameraAbilityPossessUI val = PossessUiFrom(possess);
				if (val != null)
				{
					UpdateMainControlsPrompt(val, data);
				}
			}
		}

		private static CameraAbilityPossessUI PossessUiFrom(CameraAbilityPossess possess)
		{
			object? obj = AccessTools.Field(typeof(CameraAbilityPossess), "possessUI")?.GetValue(possess);
			return (CameraAbilityPossessUI)((obj is CameraAbilityPossessUI) ? obj : null);
		}

		private static bool IsPausedOrMatchOver(CameraAbilityPossess possess)
		{
			if ((Object)(object)possess == (Object)null)
			{
				return true;
			}
			Traverse val = Traverse.Create((object)possess);
			object value = val.Field("m_gameMode").GetValue<object>();
			if (value != null)
			{
				object obj = value.GetType().GetProperty("MatchOver")?.GetValue(value);
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				if (((uint)num & (flag ? 1u : 0u)) != 0)
				{
					return true;
				}
			}
			object value2 = val.Field("m_timeService").GetValue<object>();
			if (value2 == null)
			{
				return false;
			}
			object obj2 = value2.GetType().GetMethod("IsPaused")?.Invoke(value2, null);
			bool flag2 = default(bool);
			int num2;
			if (obj2 is bool)
			{
				flag2 = (bool)obj2;
				num2 = 1;
			}
			else
			{
				num2 = 0;
			}
			return (byte)((uint)num2 & (flag2 ? 1u : 0u)) != 0;
		}

		private static void InvalidatePromptCache()
		{
			_cachedBasePrompt = null;
			_cachedPromptTmp = null;
			_cachedPromptUi = null;
		}

		private static void ClearPrompt(CameraAbilityPossessUI ui)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ui == (Object)null)
			{
				InvalidatePromptCache();
				return;
			}
			Component mainPromptTmp = GetMainPromptTmp(ui);
			if ((Object)(object)mainPromptTmp == (Object)null)
			{
				InvalidatePromptCache();
				return;
			}
			Type type = ((object)mainPromptTmp).GetType();
			string text = (type.GetProperty("text")?.GetValue(mainPromptTmp) as string) ?? string.Empty;
			string value = ((!string.IsNullOrEmpty(_cachedBasePrompt)) ? _cachedBasePrompt : StripCombatPromptSuffixes(text));
			type.GetProperty("text")?.SetValue(mainPromptTmp, value, null);
			type.GetProperty("color")?.SetValue(mainPromptTmp, PromptDefaultColor, null);
			InvalidatePromptCache();
		}

		private static void UpdateMainControlsPrompt(CameraAbilityPossessUI ui, DataHandler data)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			Component mainPromptTmp = GetMainPromptTmp(ui);
			if (!((Object)(object)mainPromptTmp == (Object)null))
			{
				Type type = ((object)mainPromptTmp).GetType();
				string text = (type.GetProperty("text")?.GetValue(mainPromptTmp) as string) ?? string.Empty;
				if ((Object)(object)_cachedPromptUi != (Object)(object)ui)
				{
					_cachedPromptUi = ui;
					_cachedBasePrompt = null;
				}
				if (string.IsNullOrEmpty(_cachedBasePrompt) || !text.Contains(" · Battle Dash "))
				{
					_cachedBasePrompt = StripCombatPromptSuffixes(text);
				}
				else if (text.Contains(" · Battle Dash "))
				{
					_cachedBasePrompt = StripCombatPromptSuffixes(text);
				}
				string text2 = _cachedBasePrompt ?? StripCombatPromptSuffixes(text);
				if (!AimExclusionStore.ShouldShowBattleDashToggle(data))
				{
					type.GetProperty("text")?.SetValue(mainPromptTmp, text2, null);
					type.GetProperty("color")?.SetValue(mainPromptTmp, PromptDefaultColor, null);
					return;
				}
				string text3 = AimExclusionStore.FormatKeyName(AimExclusionStore.GetBattleDashToggleKey());
				bool flag = BattleMeleeDashStore.IsEnabled(data);
				string text4 = (flag ? "ON" : "OFF");
				type.GetProperty("text")?.SetValue(mainPromptTmp, text2 + " · Battle Dash " + text4 + " [" + text3 + "]", null);
				type.GetProperty("color")?.SetValue(mainPromptTmp, flag ? DashOnColor : DashOffColor, null);
			}
		}

		private static string StripDashSuffix(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			int num = text.IndexOf(" · Battle Dash ", StringComparison.Ordinal);
			if (num < 0)
			{
				return text;
			}
			return text.Substring(0, num);
		}

		private static string StripCombatPromptSuffixes(string text)
		{
			return StripDashSuffix(PossessionAutoShootToggle.StripAutoShootSuffix(text));
		}

		private static Component GetMainPromptTmp(CameraAbilityPossessUI ui)
		{
			if ((Object)(object)_cachedPromptTmp != (Object)null && (Object)(object)_cachedPromptUi == (Object)(object)ui)
			{
				return _cachedPromptTmp;
			}
			_cachedPromptUi = ui;
			_cachedPromptTmp = null;
			object obj = MainControlsPromptField?.GetValue(ui);
			if (obj == null)
			{
				return null;
			}
			object? obj2 = obj.GetType().GetProperty("Text")?.GetValue(obj);
			Component val = (Component)((obj2 is Component) ? obj2 : null);
			if (val != null)
			{
				_cachedPromptTmp = val;
				return _cachedPromptTmp;
			}
			Component val2 = (Component)((obj is Component) ? obj : null);
			if (val2 == null)
			{
				return null;
			}
			Type type = AccessTools.TypeByName("TMPro.TextMeshProUGUI");
			if (type == null)
			{
				return null;
			}
			_cachedPromptTmp = val2.GetComponent(type) ?? val2.GetComponentInChildren(type, true);
			return _cachedPromptTmp;
		}
	}
	internal static class PossessionCrosshairAim
	{
		internal struct AimTarget
		{
			public Rigidbody MainRig;

			public bool IsPredictive;
		}

		private sealed class UnitAimSmoothState
		{
			public Vector3 Position;

			public Vector3 PositionVelocity;

			public float AlongRay;

			public float AlongRayVelocity;
		}

		private static readonly Dictionary<Unit, UnitAimSmoothState> SmoothStates = new Dictionary<Unit, UnitAimSmoothState>();

		private static int _crosshairRayFrame = -1;

		private static float _crosshairRayDist;

		private static bool _crosshairRayAllowSoft;

		private static Vector3 _crosshairRayCamPos;

		private static Vector3 _crosshairRayCamFwd;

		private static Vector3 _crosshairRayAimPoint;

		private static AimTarget _crosshairRayTarget;

		private static bool _crosshairRayValid;

		internal static void ClearSmoothingCache()
		{
			SmoothStates.Clear();
			PossessionUnitTargetQuery.ClearCache();
			_crosshairRayFrame = -1;
			_crosshairRayValid = false;
		}

		private static bool TryGetCachedCrosshairRay(float maxDistance, bool allowSoftTargets, Camera camera, out Vector3 aimPoint, out AimTarget target)
		{
			//IL_0001: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			aimPoint = default(Vector3);
			target = default(AimTarget);
			if (!_crosshairRayValid || _crosshairRayFrame != Time.frameCount || (Object)(object)camera == (Object)null)
			{
				return false;
			}
			if (Mathf.Abs(Mathf.Max(maxDistance, 4f) - _crosshairRayDist) > 0.5f || allowSoftTargets != _crosshairRayAllowSoft)
			{
				return false;
			}
			Vector3 position = ((Component)camera).transform.position;
			Vector3 forward = ((Component)camera).transform.forward;
			Vector3 val = position - _crosshairRayCamPos;
			if (((Vector3)(ref val)).sqrMagnitude > 0.04f || Vector3.Angle(_crosshairRayCamFwd, forward) > 2f)
			{
				return false;
			}
			aimPoint = _crosshairRayAimPoint;
			target = _crosshairRayTarget;
			return true;
		}

		private static bool StoreCrosshairRay(float maxDistance, bool allowSoftTargets, Camera camera, Vector3 aimPoint, AimTarget target, bool allowFrameCache = true)
		{
			//IL_0035: 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_0045: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)camera == (Object)null)
			{
				return true;
			}
			if (allowFrameCache)
			{
				_crosshairRayFrame = Time.frameCount;
				_crosshairRayDist = Mathf.Max(maxDistance, 4f);
				_crosshairRayAllowSoft = allowSoftTargets;
				_crosshairRayCamPos = ((Component)camera).transform.position;
				_crosshairRayCamFwd = ((Component)camera).transform.forward;
				_crosshairRayAimPoint = aimPoint;
				_crosshairRayTarget = target;
				_crosshairRayValid = true;
			}
			return true;
		}

		internal static bool IsValidTargetUnit(CameraAbilityPossess possess, Unit candidate)
		{
			return IsValidPredictiveTarget(possess, candidate);
		}

		internal static float GetUnitSizeSlack(Unit unit)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)unit == (Object)null)
			{
				return 0.5f;
			}
			float num = Mathf.Max(0.5f, ((Component)unit).transform.root.localScale.x);
			return Mathf.Max(unit.thickness, num * 0.35f);
		}

		internal static bool TryGetClosestPointOnUnitToRay(Unit unit, Ray ray, out Vector3 closestPoint, out float alongRay)
		{
			//IL_0001: 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_0054: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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)
			closestPoint = default(Vector3);
			alongRay = 0f;
			if ((Object)(object)unit == (Object)null)
			{
				return false;
			}
			float num = float.PositiveInfinity;
			bool flag = false;
			Collider[] componentsInChildren = ((Component)unit).GetComponentsInChildren<Collider>();
			foreach (Collider val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || !val.enabled)
				{
					continue;
				}
				Bounds bounds = val.bounds;
				Vector3 val2 = ((Bounds)(ref bounds)).extents;
				if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
				{
					continue;
				}
				float num2 = Vector3.Dot(((Bounds)(ref bounds)).center - ((Ray)(ref ray)).origin, ((Ray)(ref ray)).direction);
				Vector3 val3 = ((Ray)(ref ray)).origin + ((Ray)(ref ray)).direction * num2;
				Vector3 val4 = val.ClosestPoint(val3);
				float num3 = Vector3.Dot(val4 - ((Ray)(ref ray)).origin, ((Ray)(ref ray)).direction);
				if (!(num3 < 0f))
				{
					Vector3 val5 = ((Ray)(ref ray)).origin + ((Ray)(ref ray)).direction * num3;
					val2 = val4 - val5;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (!(sqrMagnitude >= num))
					{
						num = sqrMagnitude;
						closestPoint = val4;
						alongRay = num3;
						flag = true;
					}
				}
			}
			if (flag)
			{
				return true;
			}
			if ((Object)(object)unit.data?.mainRig != (Object)null)
			{
				closestPoint = unit.data.mainRig.position;
				alongRay = Vector3.Dot(closestPoint - ((Ray)(ref ray)).origin, ((Ray)(ref ray)).direction);
				return alongRay >= 0f;
			}
			return false;
		}

		internal static Vector3 ProjectOntoCrosshairRay(Ray ray, Vector3 worldPoint)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_001c: 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_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)
			float num = Vector3.Dot(worldPoint - ((Ray)(ref ray)).origin, ((Ray)(ref ray)).direction);
			return ((Ray)(ref ray)).origin + ((Ray)(ref ray)).direction * Mathf.Max(0.5f, num);
		}

		internal static bool TryGetPossessionCamera(out Camera camera, out CameraAbilityPossess possess)
		{
			possess = PossessionFreeAimLogic.GetPossess();
			camera = null;
			if ((Object)(object)possess != (Object)null)
			{
				camera = ((Component)possess).GetComponentInChildren<Camera>();
			}
			if ((Object)(object)camera == (Object)null && (Object)(object)MainCam.instance != (Object)null)
			{
				camera = ((Component)MainCam.instance).GetComponent<Camera>();
				if ((Object)(object)camera == (Object)null)
				{
					camera = ((Component)MainCam.instance).GetComponentInChildren<Camera>();
				}
			}
			return (Object)(object)camera != (Object)null;
		}

		internal static bool TryGetCrosshairAimPoint(float maxDistance, out Vector3 aimPoint)
		{
			AimTarget target;
			return TryGetCrosshairAimPoint(maxDistance, out aimPoint, out target, allowSoftTargets: true);
		}

		internal static bool TryGetCrosshairAimPoint(float maxDistance, out Vector3 aimPoint, out AimTarget target, bool allowSoftTargets, bool allowFrameCache = true)
		{
			//IL_0001: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: 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_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			aimPoint = default(Vector3);
			target = default(AimTarget);
			if (PossessionFreeAimLogic.IsSandboxPlacement())
			{
				return false;
			}
			if (!TryGetPossessionCamera(out var camera, out var possess))
			{
				return false;
			}
			if (allowFrameCache && TryGetCachedCrosshairRay(maxDistance, allowSoftTargets, camera, out aimPoint, out target))
			{
				return true;
			}
			float num = Mathf.Max(maxDistance, 4f);
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)camera).transform.position, ((Component)camera).transform.forward);
			if (allowSoftTargets && PossessionUnitTargetQuery.TryGetCachedAimSnapshot(possess, camera, num, out var snapshot))
			{
				if ((Object)(object)snapshot.AimTarget.MainRig != (Object)null)
				{
					aimPoint = ProjectOntoCrosshairRay(val, snapshot.AimPoint);
					target = snapshot.AimTarget;
					if (snapshot.HasAimPoint)
					{
						return StoreCrosshairRay(maxDistance, allowSoftTargets, camera, aimPoint, target, allowFrameCache);
					}
					return false;
				}
				if (allowSoftTargets && TryFindSoftTargetOnRay(possess, camera, val, num, out var alongRay, out var unit))
				{
					aimPoint = ((Ray)(ref val)).origin + ((Ray)(ref val)).direction * alongRay;
					target = CreateAimTarget(unit);
					return StoreCrosshairRay(maxDistance, allowSoftTargets, camera, aimPoint, target, allowFrameCache);
				}
				if (snapshot.HasAimPoint)
				{
					aimPoint = snapshot.AimPoint;
					target = snapshot.AimTarget;
					return StoreCrosshairRay(maxDistance, allowSoftTargets, camera, aimPoint, target, allowFrameCache);
				}
			}
			RaycastHit[] array = Physics.RaycastAll(val, num, PossessionUnitTargetQuery.GetRaycastLayerMask(possess), (QueryTriggerInteraction)2);
			if (array != null && array.Length > 1)
			{
				Array.Sort(array, (RaycastHit a, RaycastHit b) => ((RaycastHit)(ref a)).distance.CompareTo(((RaycastHit)(ref b)).distance));
			}
			if (array != null && allowSoftTargets)
			{
				RaycastHit[] array2 = array;
				for (int i = 0; i < array2.Length; i++)
				{
					RaycastHit val2 = array2[i];
					Unit componentInParent = ((Component)((RaycastHit)(ref val2)).collider).GetComponentInParent<Unit>();
					if (IsValidPredictiveTarget(possess, componentInParent))
					{
						aimPoint = ((RaycastHit)(ref val2)).point;
						target = CreateAimTarget(componentInParent);
						return StoreCrosshairRay(maxDistance, allowSoftTargets, camera, aimPoint, target, allowFrameCache);
					}
				}
			}
			if (array != null && !allowSoftTargets)
			{
				RaycastHit[] array2 = array;
				for (int i = 0; i < array2.Length; i++)
				{
					RaycastHit val3 = array2[i];
					if (!((Object)(object)((Component)((RaycastHit)(ref val3)).collider).GetComponentInParent<Unit>() != (Object)null))
					{
						aimPoint = ((RaycastHit)(ref val3)).point;
						return StoreCrosshairRay(maxDistance, allowSoftTargets, camera, aimPoint, target, allowFrameCache);
					}
				}
			}
			if (allowSoftTargets && array != null && TryGetFirstNonSelfAimPoint(possess, array, out aimPoint))
			{
				return StoreCrosshairRay(maxDistance, allowSoftTargets, camera, aimPoint, target, allowFrameCache);
			}
			if (allowSoftTargets && TryFindSoftTargetOnRay(possess, camera, val, num, out var alongRay2, out var unit2))
			{
				aimPoint = ((Ray)(ref val)).origin + ((Ray)(ref val)).direction * alongRay2;
				target = CreateAimTarget(unit2);
				return StoreCrosshairRay(maxDistance, allowSoftTargets, camera, aimPoint, target, allowFrameCache);
			}
			aimPoint = ((Ray)(ref val)).origin + ((Ray)(ref val)).direction * num;
			return StoreCrosshairRay(maxDistance, allowSoftTargets, camera, aimPoint, target, allowFrameCache);
		}

		internal static bool TryGetAimDirection(DataHandler data, float maxDistance, out Vector3 direction, out Vector3 lookPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0035: 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_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_0025: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			direction = default(Vector3);
			lookPoint = default(Vector3);
			if (!PossessionFreeAimLogic.TryGetCameraAim(out var aim, out var _))
			{
				return false;
			}
			if (!TryGetCrosshairAimPoint(maxDistance, out lookPoint))
			{
				direction = aim;
				return true;
			}
			Vector3 aimOrigin = GetAimOrigin(data);
			Vector3 val = lookPoint - aimOrigin;
			if (((Vector3)(ref val)).sqrMagnitude > 0.01f)
			{
				direction = ((Vector3)(ref val)).normalized;
			}
			else
			{
				direction = aim;
			}
			return true;
		}

		internal static float GetAimDistanceForHandler(DataHandler data)
		{
			return PossessionWeaponRange.GetMapCrosshairDistance();
		}

		internal static float GetAimDistanceForWeapon(RangeWeapon weapon)
		{
			return PossessionWeaponRange.GetMapCrosshairDistance();
		}

		internal static Vector3 GetAimOrigin(DataHandler data)
		{
			//IL_001a: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)data?.torso != (Object)null)
			{
				return data.torso.position;
			}
			if ((Object)(object)data?.mainRig != (Object)null)
			{
				return data.mainRig.position;
			}
			if ((Object)(object)data?.characterForwardObject != (Object)null)
			{
				return data.characterForwardObject.position;
			}
			if (!((Object)(object)MainCam.instance != (Object)null))
			{
				return Vector3.zero;
			}
			return ((Component)MainCam.instance).transform.position;
		}

		private static bool TryFindSoftTargetOnRay(CameraAbilityPossess possess, Camera camera, Ray ray, float maxDistance, out float alongRay, out Unit unit)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			alongRay = -1f;
			unit = null;
			if ((Object)(object)possess == (Object)null || (Object)(object)possess.currentUnit == (Object)null || (Object)(object)camera == (Object)null)
			{
				return false;
			}
			Unit[] unitsOnCrosshairRay = PossessionUnitTargetQuery.GetUnitsOnCrosshairRay(possess, camera, maxDistance);
			if (unitsOnCrosshairRay.Length == 0)
			{
				return false;
			}
			float num = 5f;
			float num2 = float.PositiveInfinity;
			float num3 = -1f;
			Unit val = null;
			Unit[] array = unitsOnCrosshairRay;
			foreach (Unit val2 in array)
			{
				if (!IsValidPredictiveTarget(possess, val2) || (Object)(object)val2.data?.mainRig == (Object)null || !TryGetClosestPointOnUnitToRay(val2, ray, out var closestPoint, out var alongRay2))
				{
					continue;
				}
				Vector3 stableUnitAimReference = GetStableUnitAimReference(val2, ray);
				Vector3 val3 = stableUnitAimReference - ((Ray)(ref ray)).origin;
				alongRay2 = Vector3.Dot(val3, ((Ray)(ref ray)).direction);
				float unitSizeSlack = GetUnitSizeSlack(val2);
				if (alongRay2 < 0.5f || alongRay2 > maxDistance + unitSizeSlack)
				{
					continue;
				}
				float num4 = Vector3.Angle(((Ray)(ref ray)).direction, ((Vector3)(ref val3)).normalized);
				if (!(num4 > num + 57.29578f * Mathf.Atan(unitSizeSlack / Mathf.Max(alongRay2, 1f))))
				{
					closestPoint = ((Ray)(ref ray)).origin + ((Ray)(ref ray)).direction * alongRay2 - stableUnitAimReference;
					float sqrMagnitude = ((Vector3)(ref closestPoint)).sqrMagnitude;
					float num5 = num4 + alongRay2 * 0.01f + sqrMagnitude * 0.02f;
					if (!(num5 >= num2))
					{
						num2 = num5;
						num3 = SmoothAlongRay(val2, alongRay2);
						val = val2;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			alongRay = num3;
			unit = val;
			return true;
		}

		internal static void PruneSmoothingCache(HashSet<Unit> activeUnits = null)
		{
			if (SmoothStates.Count == 0)
			{
				return;
			}
			List<Unit> list = new List<Unit>();
			foreach (KeyValuePair<Unit, UnitAimSmoothState> smoothState in SmoothStates)
			{
				if ((Object)(object)smoothState.Key == (Object)null || (Object)(object)smoothState.Key.data == (Object)null || smoothState.Key.data.Dead)
				{
					list.Add(smoothState.Key);
				}
				else if (activeUnits != null && !activeUnits.Contains(smoothState.Key))
				{
					list.Add(smoothState.Key);
				}
			}
			for (int i = 0; i < list.Count; i++)
			{
				SmoothStates.Remove(list[i]);
			}
		}

		private static Vector3 GetStableUnitAimReference(Unit unit, Ray ray)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			if (TryGetClosestPointOnUnitToRay(unit, ray, out var closestPoint, out var _))
			{
				return SmoothUnitAimPoint(unit, closestPoint);
			}
			return SmoothUnitAimPoint(unit, GetRawUnitAimReference(unit));
		}

		private static Vector3 SmoothUnitAimPoint(Unit unit, Vector3 raw)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0068: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)unit == (Object)null)
			{
				return raw;
			}
			if (!SmoothStates.TryGetValue(unit, out var value))
			{
				value = new UnitAimSmoothState
				{
					Position = raw,
					AlongRay = 0f
				};
				SmoothStates[unit] = value;
			}
			float num = Mathf.Max(0.02f, 0.15f);
			value.Position = Vector3.SmoothDamp(value.Position, raw, ref value.PositionVelocity, num);
			return value.Position;
		}

		private static Vector3 GetStableUnitAimReference(Unit unit)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Vector3 rawUnitAimReference = GetRawUnitAimReference(unit);
			return SmoothUnitAimPoint(unit, rawUnitAimReference);
		}

		private static float SmoothAlongRay(Unit unit, float rawAlong)
		{
			//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)
			if ((Object)(object)unit == (Object)null)
			{
				return rawAlong;
			}
			if (!SmoothStates.TryGetValue(unit, out var value))
			{
				value = new UnitAimSmoothState
				{
					Position = GetRawUnitAimReference(unit),
					AlongRay = rawAlong
				};
				SmoothStates[unit] = value;
				return rawAlong;
			}
			float num = Mathf.Max(0.02f, 0.15f);
			value.AlongRay = Mathf.SmoothDamp(value.AlongRay, rawAlong, ref value.AlongRayVelocity, num);
			return value.AlongRay;
		}

		private static Vector3 GetRawUnitAimReference(Unit unit)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_005f: 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_00af: 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)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)unit?.data?.torso != (Object)null)
			{
				Transform torso = unit.data.torso;
				float num = Mathf.Max(0.5f, ((Component)unit).transform.root.localScale.x);
				return torso.position + torso.up * (0.45f * num);
			}
			if ((Object)(object)unit?.data?.mainRig != (Object)null)
			{
				return unit.data.mainRig.position + Vector3.up * 0.5f;
			}
			return Vector3.zero;
		}

		internal static bool TryFindAbilityTarget(CameraAbilityPossess possess, float maxAngleDegrees, out Unit unit, out float distanceToTarget)
		{
			unit = null;
			distanceToTarget = 0f;
			if ((Object)(object)possess == (Object)null || (Object)(object)possess.currentUnit == (Object)null)
			{
				return false;
			}
			return TryGetPrimaryRayTargetFromQuery(possess, maxAngleDegrees, out unit, out distanceToTarget);
		}

		internal static bool TryGetPrimaryRayTargetFromQuery(CameraAbilityPossess possess, float maxAngleDegrees, out Unit unit, out float distanceToTarget)
		{
			unit = null;
			distanceToTarget = 0f;
			if (!TryGetPossessionCamera(out var camera, out var _))
			{
				return false;
			}
			return PossessionUnitTargetQuery.TryGetPrimaryRayTarget(possess, camera, maxAngleDegrees, out unit, out distanceToTarget);
		}

		internal static bool IsPossessedUnitCollider(CameraAbilityPossess possess, Collider collider)
		{
			if ((Object)(object)collider == (Object)null || (Object)(object)possess?.currentUnit == (Object)null)
			{
				return false;
			}
			return (Object)(object)((Component)collider).transform.root == (Object)(object)((Component)possess.currentUnit).transform.root;
		}

		private static bool TryGetFirstNonSelfAimPoint(CameraAbilityPossess possess, RaycastHit[] hits, out Vector3 aimPoint)
		{
			//IL_0001: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			aimPoint = default(Vector3);
			if (hits == null || hits.Length == 0)
			{
				return false;
			}
			for (int i = 0; i < hits.Length; i++)
			{
				if (!IsPossessedUnitCollider(possess, ((RaycastHit)(ref hits[i])).collider))
				{
					aimPoint = ((RaycastHit)(ref hits[i])).point;
					return true;
				}
			}
			return false;
		}

		private static bool IsValidPredictiveTarget(CameraAbilityPossess possess, Unit candidate)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)candidate == (Object)null || (Object)(object)candidate.data == (Object)null || candidate.data.Dead || (Object)(object)candidate.data.mainRig == (Object)null)
			{
				return false;
			}
			if ((Object)(object)possess.currentUnit != (Object)null && (Object)(object)((Component)candidate).transform.root == (Object)(object)((Component)possess.currentUnit).transform.root)
			{
				return false;
			}
			if ((Object)(object)possess.currentUnit != (Object)null && candidate.Team == possess.currentUnit.Team && !possess.currentUnit.targetYourFriends)
			{
				return false;
			}
			return true;
		}

		internal static AimTarget CreateAimTarget(Unit unit)
		{
			AimTarget result = default(AimTarget);
			result.MainRig = unit?.data?.mainRig;
			result.IsPredictive = (Object)(object)unit?.data?.mainRig != (Object)null;
			return result;
		}
	}
	internal static class PossessionFirstPersonCamera
	{
		internal static bool ShouldStabilize(Unit unit)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if ((Object)(object)unit == (Object)null)
			{
				return false;
			}
			RigType rigType = unit.RigType;
			if ((int)rigType == 1 || (int)rigType == 2 || (int)rigType == 5)
			{
				return true;
			}
			return IsStiffyUnit(unit);
		}

		internal static bool IsStiffyUnit(Unit unit)
		{
			if ((((Object)unit).name ?? string.Empty).IndexOf("stiffy", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			UnitBlueprint unitBlueprint = unit.unitBlueprint;
			object obj;
			if (unitBlueprint == null)
			{
				obj = null;
			}
			else
			{
				DatabaseEntity entity = unitBlueprint.Entity;
				obj = ((entity != null) ? entity.Name : null);
			}
			if (obj == null)
			{
				obj = string.Empty;
			}
			return ((string)obj).IndexOf("stiffy", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		internal static Vector3 GetEyePosition(Unit unit)
		{
			//IL_0031: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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)
			if ((Object)(object)unit?.data == (Object)null)
			{
				return Vector3.zero;
			}
			DataHandler data = unit.data;
			float num = Mathf.Max(0.5f, ((Component)unit).transform.root.localScale.x);
			float num2 = 0.42f * num;
			float num3 = 0.06f * num;
			object obj;
			if (!((Object)(object)data.torso != (Object)null))
			{
				Rigidbody mainRig = data.mainRig;
				obj = ((mainRig != null) ? ((Component)mainRig).transform : null);
			}
			else
			{
				obj = data.torso;
			}
			Transform val = (Transform)obj;
			if ((Object)(object)val == (Object)null)
			{
				return ((Component)unit).transform.position + Vector3.up * num2;
			}
			Vector3 val2 = (((Object)(object)data.characterForwardObject != (Object)null) ? data.characterForwardObject.forward : val.forward);
			val2.y = 0f;
			if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
			{
				val2 = val.forward;
			}
			((Vector3)(ref val2)).Normalize();
			return val.position + Vector3.up * num2 + val2 * num3;
		}
	}
	internal static class PossessionFreeAimLogic
	{
		private static CameraAbilityPossess _possess;

		private static DataHandler _possessedData;

		private static int _lastNonCombatCheckFrame = -1;

		private static bool _cachedNonCombatUi;

		private static int _gameplayContextCheckFrame = -1;

		private static bool _cachedGameplayContext;

		private static CustomContetnManager _cachedCustomContentManager;

		private static int _cachedCustomContentSceneHandle = -1;

		private static bool _customContentSearchDoneForScene;

		private static bool _sceneHooksRegistered;

		internal static bool IsSandboxPlacement()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			GameStateManager service = ServiceLocator.GetService<GameStateManager>();
			if (service != null)
			{
				return (int)service.GameState == 0;
			}
			return false;
		}

		internal static bool IsUnitCreatorScene()
		{
			return TABSSceneManager.IsInUnitCreatorScene();
		}

		internal static void InitializeSceneHooks()
		{
			if (!_sceneHooksRegistered)
			{
				SceneManager.sceneLoaded += OnSceneLoaded;
				SceneManager.sceneUnloaded += OnSceneUnloaded;
				_sceneHooksRegistered = true;
			}
		}

		internal static bool IsNonCombatUiScene()
		{
			if (Time.frameCount == _lastNonCombatCheckFrame)
			{
				return _cachedNonCombatUi;
			}
			_lastNonCombatCheckFrame = Time.frameCount;
			_cachedNonCombatUi = ComputeNonCombatUiScene();
			return _cachedNonCombatUi;
		}

		private static bool ComputeNonCombatUiScene()
		{
			if (TABSSceneManager.IsInCustomContentPage())
			{
				return true;
			}
			if (TABSSceneManager.IsInUnitCreatorScene())
			{
				return true;
			}
			if (!TABSSceneManager.IsInGameScene())
			{
				return true;
			}
			if (TABSSceneManager.IsLoading)
			{
				return false;
			}
			try
			{
				MainMenuButtons instance = MainMenuButtons.Instance;
				if ((Object)(object)instance != (Object)null && (Object)(object)instance != (Object)null && ((UIComponentBase)instance).IsActive)
				{
					return true;
				}
				return IsCachedCustomContentOverlayActive();
			}
			catch
			{
				return false;
			}
		}

		internal static void InvalidateNonCombatUiCache()
		{
			_lastNonCombatCheckFrame = -1;
		}

		internal static void InvalidatePossessionGameplayCache()
		{
			_gameplayContextCheckFrame = -1;
		}

		internal static bool IsPossessionGameplayContext()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_0063: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Invalid comparison between Unknown and I4
			if (Time.frameCount == _gameplayContextCheckFrame)
			{
				return _cachedGameplayContext;
			}
			_gameplayContextCheckFrame = Time.frameCount;
			if (!FirstPersonFreeAimConfig.Enabled)
			{
				_cachedGameplayContext = false;
				return false;
			}
			if (IsNonCombatUiScene())
			{
				_cachedGameplayContext = false;
				return false;
			}
			if (!TABSSceneManager.IsInGameScene())
			{
				_cachedGameplayContext = false;
				return false;
			}
			GameStateManager service = ServiceLocator.GetService<GameStateManager>();
			if (service == null)
			{
				_cachedGameplayContext = false;
				return false;
			}
			GameState gameState = service.GameState;
			_cachedGameplayContext = (int)gameState == 1 || (int)gameState == 0;
			return _cachedGameplayContext;
		}

		private static bool IsCachedCustomContentOverlayActive()
		{
			RefreshCustomContentManagerCacheIfNeeded();
			CustomContetnManager cachedCustomContentManager = _cachedCustomContentManager;
			if ((Object)(object)cachedCustomContentManager == (Object)null || (Object)(object)cachedCustomContentManager == (Object)null)
			{
				_cachedCustomContentManager = null;
				return false;
			}
			return ((UIComponentBase)cachedCustomContentManager).IsActive;
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			InvalidateNonCombatUiCache();
			InvalidatePossessionGameplayCache();
			ClearCustomContentManagerCache();
			ClearPossessCache();
		}

		private static void OnSceneUnloaded(Scene scene)
		{
			InvalidateNonCombatUiCache();
			InvalidatePossessionGameplayCache();
			ClearCustomContentManagerCache();
			ClearPossessCache();
		}

		private static void ClearCustomContentManagerCache()
		{
			_cachedCustomContentManager = null;
			_cachedCustomContentSceneHandle = -1;
			_customContentSearchDoneForScene = false;
		}

		private static void RefreshCustomContentManagerCacheIfNeeded()
		{
			//IL_000f: 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)
			if (TABSSceneManager.IsLoading || !TABSSceneManager.IsInGameScene())
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (_cachedCustomContentSceneHandle != ((Scene)(ref activeScene)).handle || (!((Object)(object)_cachedCustomContentManager != (Object)null) && !_customContentSearchDoneForScene))
			{
				try
				{
					_cachedCustomContentManager = Object.FindObjectOfType<CustomContetnManager>();
				}
				catch (Exception ex)
				{
					Plugin.LogWarning("Possession UI overlay lookup failed: " + ex.Message);
					_cachedCustomContentManager = null;
				}
				_cachedCustomContentSceneHandle = ((Scene)(ref activeScene)).handle;
				_customContentSearchDoneForScene = true;
			}
		}

		internal static bool ShouldRunPossessionFeatures()
		{
			return IsPossessionGameplayContext();
		}

		internal static void ClearPossessCache()
		{
			_possess = null;
			_possessedData = null;
		}

		internal static bool ShouldApply()
		{
			if (ShouldRunPossessionFeatures() && !IsSandboxPlacement())
			{
				CameraAbilityPossess possess = GetPossess();
				if (possess != null)
				{
					return possess.IsPossessing;
				}
				return false;
			}
			return false;
		}

		internal static bool IsPossessedUnit(DataHandler data)
		{
			if ((Object)(object)data == (Object)null || !data.input.hasControl)
			{
				return false;
			}
			if (!ShouldRunPossessionFeatures())
			{
				return false;
			}
			if ((Object)(object)_possessedData != (Object)null)
			{
				return (Object)(object)data == (Object)(object)_possessedData;
			}
			CameraAbilityPossess possess = GetPossess();
			if ((Object)(object)possess != (Object)null && possess.IsPossessing && (Object)(object)possess.currentUnit != (Object)null)
			{
				return (Object)(object)possess.currentUnit.data == (Object)(object)data;
			}
			return false;
		}

		internal static bool ShouldApplyCrosshairAim(DataHandler data)
		{
			if (IsPossessedUnit(data))
			{
				return AimExclusionStore.ShouldUseCrosshairAim(data);
			}
			return false;
		}

		internal static bool ShouldApplyCrosshairAim(Unit unit)
		{
			if ((Object)(object)unit == (Object)null)
			{
				return false;
			}
			CameraAbilityPossess possess = GetPossess();
			if ((Object)(object)possess != (Object)null && possess.IsPossessing && (Object)(object)possess.currentUnit == (Object)(object)unit)
			{
				return AimExclusionStore.ShouldUseCrosshairAim(unit);
			}
			return false;
		}

		internal static bool ShouldBlockAttackerAutoTargeting(DataHandler attackerData)
		{
			if (ShouldRunPossessionFeatures())
			{
				return ShouldApplyCrosshairAim(attackerData);
			}
			return false;
		}

		internal static void ClearTarget(DataHandler data)
		{
			if (!((Object)(object)data == (Object)null))
			{
				data.targetMainRig = null;
				data.targetData = null;
				data.inRange = false;
				data.distanceToTarget = float.PositiveInfinity;
			}
		}

		internal static bool TryGetCameraAim(out Vector3 aim)
		{
			Vector3 up;
			return TryGetCameraAim(out aim, out up);
		}

		internal static bool TryGetCameraAim(out Vector3 aim, out Vector3 up)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			aim = default(Vector3);
			up = Vector3.up;
			if (!ShouldRunPossessionFeatures() || IsSandboxPlacement())
			{
				return false;
			}
			if (!PossessionCrosshairAim.TryGetPossessionCamera(out var camera, out var possess))
			{
				return false;
			}
			if ((Object)(object)possess == (Object)null || !possess.IsPossessing)
			{
				return false;
			}
			aim = ((Component)camera).transform.forward;
			up = ((Component)camera).transform.up;
			return ((Vector3)(ref aim)).sqrMagnitude > 0.0001f;
		}

		internal static void ApplyHoldableAim(DataHandler handler, HoldableDataInstance holdableData, Holdable holdable = null)
		{
			//IL_003e: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)handler == (Object)null) && holdableData != null && !((Object)(object)handler.characterForwardObject == (Object)null) && TryGetCameraAim(out var aim, out var up))
			{
				float aimDistanceForHandler = PossessionCrosshairAim.GetAimDistanceForHandler(handler);
				if (PossessionCrosshairAim.TryGetAimDirection(handler, aimDistanceForHandler, out var direction, out aim) && !PossessionRangedHold.TryApplyTiltedHold(holdable, handler, direction, holdableData))
				{
					holdableData.forwardRotation = handler.characterForwardObject.InverseTransformDirection(direction);
					holdableData.upRotation = handler.characterForwardObject.InverseTransformDirection(up);
				}
			}
		}

		internal static void ApplyAttackAim(ref Rigidbody targetRig, ref Vector3 forceDirection, bool clearTargetRig = true)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			DataHandler data = GetPossess()?.currentUnit?.data;
			float aimDistanceForHandler = PossessionCrosshairAim.GetAimDistanceForHandler(data);
			if (PossessionCrosshairAim.TryGetAimDirection(data, aimDistanceForHandler, out var direction, out var _))
			{
				if (clearTargetRig)
				{
					targetRig = null;
				}
				forceDirection = direction;
			}
		}

		internal static void ApplyRangeWeaponAttackAim(ref Vector3 forceDirection)
		{
			Rigidbody targetRig = null;
			ApplyAttackAim(ref targetRig, ref forceDirection, clearTargetRig: false);
		}

		internal static void ApplyPossessionAbilityTarget(CameraAbilityPossess possess, Rigidbody targetRig, float distanceToTarget)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0039: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)possess?.currentUnit == (Object)null) && !((Object)(object)targetRig == (Object)null))
			{
				Vector3 val = ((Component)targetRig).transform.position - possess.currentUnit.PredicedPosition;
				float magnitude = ((Vector3)(ref val)).magnitude;
				TargetData val2 = default(TargetData);
				val2.DistanceToTarget = distanceToTarget;
				val2.TargetInAttackRange = ((magnitude <= possess.currentUnit.m_AttackDistance) ? 1 : 0);
				val2.TargetInPreferredRange = ((magnitude <= possess.currentUnit.m_PreferedDistance) ? 1 : 0);
				TargetData val3 = val2;
				UnitAPI api = possess.currentUnit.api;
				if (api != null)
				{
					api.SetAttackTarget(float3.op_Implicit(targetRig.position), targetRig, ((Component)targetRig).GetComponentInParent<DataHandler>(), val3, true, true);
				}
			}
		}

		internal static void ApplyPossessionLook(Unit unit)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)unit?.data == (Object)null)
			{
				return;
			}
			float aimDistanceForHandler = PossessionCrosshairAim.GetAimDistanceForHandler(unit.data);
			if (PossessionCrosshairAim.TryGetAimDirection(unit.data, aimDistanceForHandler, out var direction, out var _))
			{
				UnitAPI api = unit.api;
				if (api != null)
				{
					api.SetLookDirection(direction, true);
				}
			}
		}

		internal static CameraAbilityPossess GetPossess()
		{
			if (!ShouldRunPossessionFeatures())
			{
				return null;
			}
			if ((Object)(object)_possess != (Object)null && _possess.IsPossessing && !IsSandboxPlacement())
			{
				_possessedData = _possess.currentUnit?.data;
				return _possess;
			}
			CameraAbilityPossess val = null;
			if ((Object)(object)MainCam.instance != (Object)null)
			{
				val = ((Component)MainCam.instance).GetComponentInParent<CameraAbilityPossess>() ?? ((Component)MainCam.instance).GetComponentInChildren<CameraAbilityPossess>() ?? ((Component)MainCam.instance).GetComponent<CameraAbilityPossess>();
			}
			if ((Object)(object)val != (Object)null)
			{
				if (val.IsPossessing && !IsSandboxPlacement())
				{
					_possess = val;
					_possessedData = val.currentUnit?.data;
				}
				else
				{
					_possessedData = null;
				}
				return val;
			}
			CameraAbilityPossess[] array = Object.FindObjectsOfType<CameraAbilityPossess>();
			foreach (CameraAbilityPossess val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null) && val2.IsPossessing && !IsSandboxPlacement())
				{
					_possess = val2;
					_possessedData = val2.currentUnit?.data;
					return _possess;
				}
			}
			if ((Object)(object)_possess != (Object)null && (!_possess.IsPossessing || IsSandboxPlacement()))
			{
				_possess = null;
				_possessedData = null;
			}
			return _possess;
		}
	}
	internal static class PossessionFreeAimPatches
	{
		private static readonly FieldInfo TargetRigField = AccessTools.Field(typeof(CameraAbilityPossess), "targetRig");

		private static readonly Dictionary<CameraAbilityPossess, Vector3> CameraSmoothVelocity = new Dictionary<CameraAbilityPossess, Vector3>();

		private static readonly FieldInfo HoldingHandlerDataField = typeof(HoldingHandler).GetField("data", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo RightObjectField = typeof(HoldingHandler).GetField("rightObject", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo LeftObjectField = typeof(HoldingHandler).GetField("leftObject", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public static void LateUpdate_Postfix(CameraAbilityPossess __instance)
		{
			if (PossessionFreeAimLogic.ShouldRunPossessionFeatures() && !((Object)(object)__instance == (Object)null) && __instance.IsPossessing)
			{
				PossessionZoom.Update(__instance);
			}
		}

		public static void EnterUnit_Postfix(CameraAbilityPossess __instance)
		{
			PossessionRangedHold.OnPossessEnter(__instance?.currentUnit);
			if (PossessionFreeAimLogic.ShouldRunPossessionFeatures() && PossessionCrosshairAim.TryGetPossessionCamera(out var camera, out var _))
			{
				PossessionZoom.OnPossessEnter(camera);
			}
		}

		public static void ExitUnit_Postfix()
		{
			PossessionRangedHold.OnPossessExit();
			PossessionMagazineLogic.ClearReloadTracking();
			PossessionZoom.OnPossessExit();
			PossessionCrosshairAim.ClearSmoothingCache();
			CameraSmoothVelocity.Clear();
		}

		public static void UpdateMovementAndRotation_Postfix(CameraAbilityPossess __instance)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			//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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (PossessionFreeAimLogic.ShouldRunPossessionFeatures() && !PossessionFreeAimLogic.IsSandboxPlacement() && !((Object)(object)__instance == (Object)null) && __instance.IsPossessing && (int)__instance.cameraMode == 1 && !((Object)(object)__instance.currentUnit == (Object)null) && PossessionFirstPersonCamera.ShouldStabilize(__instance.currentUnit))
			{
				Transform transform = ((Component)__instance).transform;
				Vector3 eyePosition = PossessionFirstPersonCamera.GetEyePosition(__instance.currentUnit);
				if (!CameraSmoothVelocity.TryGetValue(__instance, out var value))
				{
					value = Vector3.zero;
				}
				transform.position = Vector3.SmoothDamp(transform.position, eyePosition, ref value, Mathf.Max(0.02f, 0.14f));
				CameraSmoothVelocity[__instance] = value;
			}
		}

		public static void ToggleFPS_Postfix(CameraAbilityPossess __instance)
		{
			if (PossessionFreeAimLogic.ShouldRunPossessionFeatures() && !((Object)(object)__instance == (Object)null) && __instance.IsPossessing && PossessionCrosshairAim.TryGetPossessionCamera(out var camera, out var _))
			{
				PossessionZoom.OnCameraModeChanged(camera);
			}
		}

		[HarmonyPriority(800)]
		public static bool FindTargetRig_Prefix(CameraAbilityPossess __instance, ref float maxAngle, ref Rigidbody __result)
		{
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures() || (Object)(object)__instance == (Object)null || !__instance.IsPossessing || (Object)(object)__instance.currentUnit == (Object)null)
			{
				return true;
			}
			if (AimExclusionStore.IsUnitExcluded(__instance.currentUnit))
			{
				return true;
			}
			float maxAngleDegrees = Mathf.Max(maxAngle, 35f);
			__result = null;
			TargetRigField?.SetValue(__instance, null);
			if (PossessionCrosshairAim.TryGetPrimaryRayTargetFromQuery(__instance, maxAngleDegrees, out var unit, out var distanceToTarget) && (Object)(object)unit?.data?.mainRig != (Object)null)
			{
				Rigidbody val = (__result = unit.data.mainRig);
				TargetRigField.SetValue(__instance, val);
				PossessionFreeAimLogic.ApplyPossessionAbilityTarget(__instance, val, distanceToTarget);
			}
			return false;
		}

		public static bool WeaponHandler_Attack_Prefix(WeaponHandler __instance, ref Vector3 position, ref Rigidbody targetRig, ref Vector3 forceDirection, ForceWeapon forceWeapon)
		{
			//IL_0012: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures())
			{
				return true;
			}
			DataHandler handlerData = PossessionAttackRangeGate.GetHandlerData(__instance);
			if (PossessionAttackRangeGate.ShouldBlockHandlerAttack(__instance, handlerData, forceWeapon))
			{
				return false;
			}
			if (!PossessionFreeAimLogic.IsPossessedUnit(handlerData))
			{
				return true;
			}
			if (AimExclusionStore.IsUnitExcluded(handlerData))
			{
				return true;
			}
			if (TryGetAttackingRangeWeapon(__instance, forceWeapon, out var rangeWeapon))
			{
				if (!AimExclusionStore.ShouldUseCrosshairAim(handlerData))
				{
					return true;
				}
				PossessionProjectileAim.BeginWeaponVolley(rangeWeapon);
				PossessionFreeAimLogic.ClearTarget(handlerData);
				PossessionBallisticAim.AdjustAttackForSpecialRangeWeapon(rangeWeapon, ref targetRig, ref forceDirection);
				targetRig = null;
				return true;
			}
			if (!AimExclusionStore.ShouldUseCrosshairAim(handlerData))
			{
				return true;
			}
			if ((Object)(object)TryGetAttackingMeleeWeapon(__instance, forceWeapon) != (Object)null && PossessionMeleeDashLogic.TryGetCrosshairMeleeAttackPoint(handlerData, out var attackPoint, out var _, out var _))
			{
				position = attackPoint;
			}
			if (PossessionMeleeDashLogic.ShouldUseMeleeDash(handlerData))
			{
				PossessionMeleeDashLogic.ApplyMeleeAttackAim(ref targetRig, ref forceDirection, handlerData);
			}
			else
			{
				PossessionFreeAimLogic.ApplyAttackAim(ref targetRig, ref forceDirection);
			}
			return true;
		}

		private static MeleeWeapon TryGetAttackingMeleeWeapon(WeaponHandler handler, ForceWeapon forceWeapon)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if ((Object)(object)handler == (Object)null)
			{
				return null;
			}
			if ((int)forceWeapon != 1)
			{
				if ((int)forceWeapon == 2)
				{
					Weapon rightWeapon = handler.rightWeapon;
					return (MeleeWeapon)(object)((rightWeapon is MeleeWeapon) ? rightWeapon : null);
				}
				Weapon rightWeapon2 = handler.rightWeapon;
				return (MeleeWeapon)(((object)((rightWeapon2 is MeleeWeapon) ? rightWeapon2 : null)) ?? ((object)/*isinst with value type is only supported in some contexts*/));
			}
			Weapon leftWeapon = handler.leftWeapon;
			return (MeleeWeapon)(object)((leftWeapon is MeleeWeapon) ? leftWeapon : null);
		}

		private static bool TryGetAttackingRangeWeapon(WeaponHandler handler, ForceWeapon forceWeapon, out RangeWeapon rangeWeapon)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			rangeWeapon = null;
			if ((Object)(object)handler == (Object)null)
			{
				return false;
			}
			if ((int)forceWeapon != 1)
			{
				if ((int)forceWeapon == 2)
				{
					Weapon rightWeapon = handler.rightWeapon;
					rangeWeapon = (RangeWeapon)(object)((rightWeapon is RangeWeapon) ? rightWeapon : null);
				}
				else
				{
					Weapon rightWeapon2 = handler.rightWeapon;
					rangeWeapon = (RangeWeapon)(((object)((rightWeapon2 is RangeWeapon) ? rightWeapon2 : null)) ?? ((object)/*isinst with value type is only supported in some contexts*/));
				}
			}
			else
			{
				Weapon leftWeapon = handler.leftWeapon;
				rangeWeapon = (RangeWeapon)(object)((leftWeapon is RangeWeapon) ? leftWeapon : null);
			}
			return (Object)(object)rangeWeapon != (Object)null;
		}

		public static bool Weapon_Attack_Prefix(Weapon __instance, ref Vector3 position, ref Rigidbody targetRig, ref Vector3 forcedDirection, bool recursive)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures())
			{
				return true;
			}
			if (!recursive && PossessionAttackRangeGate.IsGateActive((__instance != null) ? __instance.connectedData : null) && !PossessionAttackRangeGate.CanAttack(__instance.connectedData, __instance))
			{
				return false;
			}
			if (!PossessionFreeAimLogic.IsPossessedUnit((__instance != null) ? __instance.connectedData : null))
			{
				return true;
			}
			if (!PossessionFreeAimLogic.ShouldApplyCrosshairAim(__instance.connectedData))
			{
				return true;
			}
			RangeWeapon val = (RangeWeapon)(object)((__instance is RangeWeapon) ? __instance : null);
			if (val != null)
			{
				PossessionProjectileAim.BeginWeaponVolley(val);
				PossessionFreeAimLogic.ClearTarget(__instance.connectedData);
				PossessionBallisticAim.AdjustAttackForSpecialRangeWeapon(val, ref targetRig, ref forcedDirection);
				targetRig = null;
				return true;
			}
			if (__instance is MeleeWeapon && PossessionMeleeDashLogic.TryGetCrosshairMeleeAttackPoint(__instance.connectedData, out var attackPoint, out var _, out var _))
			{
				position = attackPoint;
			}
			if (PossessionMeleeDashLogic.ShouldUseMeleeDash(__instance.connectedData))
			{
				PossessionMeleeDashLogic.ApplyMeleeAttackAim(ref targetRig, ref forcedDirection, __instance.connectedData);
			}
			else
			{
				PossessionFreeAimLogic.ApplyAttackAim(ref targetRig, ref forcedDirection);
			}
			return true;
		}

		public static void Holdable_BatchedUpdate_Postfix(Holdable __instance)
		{
			DataHandler val = __instance?.holderData;
			if (!((Object)(object)val == (Object)null) && val.input.hasControl && PossessionFreeAimLogic.IsPossessedUnit(val) && !AimExclusionStore.IsUnitExcluded(val) && AimExclusionStore.ShouldApplyModWeaponHold(val))
			{
				PossessionFreeAimLogic.ApplyHoldableAim(val, __instance.holdableData, __instance);
			}
		}

		public static void HoldingHandler_DoPID_Prefix(HoldingHandler __instance, PidDataInstance pidData, HoldableDataInstance holdableData, ref float multiplier)
		{
			DataHandler data = GetData(__instance);
			if (PossessionFreeAimLogic.IsPossessedUnit(data) && !AimExclusionStore.IsUnitExcluded(data) && AimExclusionStore.ShouldApplyModWeaponHold(data))
			{
				Holdable holdable = FindHoldableByPid(__instance, pidData);
				PossessionFreeAimLogic.ApplyHoldableAim(data, holdableData, holdable);
				if (!PossessionRangedHold.IsRangedHoldable(holdable))
				{
					multiplier *= 1.75f;
				}
			}
		}

		private static Holdable FindHoldableByPid(HoldingHandler holding, PidDataInstance pidData)
		{
			if ((Object)(object)holding == (Object)null || pidData == null)
			{
				return null;
			}
			object? obj = RightObjectField?.GetValue(holding);
			Holdable val = (Holdable)((obj is Holdable) ? obj : null);
			if (val?.pidData == pidData)
			{
				return val;
			}
			object? obj2 = LeftObjectField?.GetValue(holding);
			Holdable val2 = (Holdable)((obj2 is Holdable) ? obj2 : null);
			if (val2?.pidData == pidData)
			{
				return val2;
			}
			return null;
		}

		private static DataHandler GetData(HoldingHandler holding)
		{
			if ((Object)(object)holding == (Object)null || HoldingHandlerDataField == null)
			{
				return null;
			}
			object? value = HoldingHandlerDataField.GetValue(holding);
			return (DataHandler)((value is DataHandler) ? value : null);
		}
	}
	internal static class PossessionHoldAttack
	{
		private static readonly FieldInfo PlayerCameraField = AccessTools.Field(typeof(CameraAbilityPossess), "m_playerCamera");

		private static readonly FieldInfo PossessionCameraField = AccessTools.Field(typeof(CameraAbilityPossess), "possessionCamera");

		private static readonly FieldInfo CamField = AccessTools.Field(typeof(CameraAbilityPossess), "cam");

		private static readonly FieldInfo TargetRigField = AccessTools.Field(typeof(CameraAbilityPossess), "targetRig");

		private static readonly FieldInfo TimeServiceField = AccessTools.Field(typeof(CameraAbilityPossess), "m_timeService");

		internal static bool QualifiesForHoldAttack(Weapon weapon, WeaponHandler handler)
		{
			float effectiveWeaponCooldown = GetEffectiveWeaponCooldown(weapon);
			if ((Object)(object)weapon == (Object)null || effectiveWeaponCooldown <= 0f || effectiveWeaponCooldown >= 100f)
			{
				return false;
			}
			return GetEffectiveAttackInterval(weapon, handler, effectiveWeaponCooldown) < 1f;
		}

		internal static float GetEffectiveWeaponCooldown(Weapon weapon)
		{
			if ((Object)(object)weapon == (Object)null)
			{
				return float.MaxValue;
			}
			float num = weapon.internalCooldown;
			if (weapon.weaponList != null && weapon.weaponList.Length > 1)
			{
				num = Mathf.Min(num, weapon.GetLowestAttackTimeOfWeapons());
			}
			if (num >= 100f)
			{
				RangeWeapon val = (RangeWeapon)(object)((weapon is RangeWeapon) ? weapon : null);
				if (val != null && val.spawnDelay > 0f)
				{
					num = val.spawnDelay;
				}
			}
			return num;
		}

		internal static float GetEffectiveAttackInterval(Weapon weapon, WeaponHandler handler)
		{
			return GetEffectiveAttackInterval(weapon, handler, GetEffectiveWeaponCooldown(weapon));
		}

		internal static float GetEffectiveAttackInterval(Weapon weapon, WeaponHandler handler, float cooldown)
		{
			if ((Object)(object)weapon == (Object)null || cooldown <= 0f || cooldown >= 100f)
			{
				return float.MaxValue;
			}
			float num = handler?.attackSpeedMultiplier ?? 1f;
			if (weapon.isRange)
			{
				return cooldown / Mathf.Max(0.01f, num);
			}
			float num2 = Mathf.Clamp((4f + num) * 0.2f, 1f, 2f);
			return cooldown / num2;
		}

		internal static bool UnitQualifiesForAutoShoot(Unit unit)
		{
			if ((Object)(object)unit == (Object)null)
			{
				return false;
			}
			WeaponHandler componentInChildren = ((Component)unit).GetComponentInChildren<WeaponHandler>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return false;
			}
			if (QualifiesForAutoShootWeapon(componentInChildren.leftWeapon, componentInChildren))
			{
				return true;
			}
			return QualifiesForAutoShootWeapon(componentInChildren.rightWeapon, componentInChildren);
		}

		private static bool QualifiesForAutoShootWeapon(Weapon weapon, WeaponHandler handler)
		{
			if ((Object)(object)weapon == (Object)null || !weapon.isRange)
			{
				return false;
			}
			weapon = weapon.GetBestWeaponOnWeapon() ?? weapon;
			return QualifiesForHoldAttack(weapon, handler);
		}

		internal static bool ShouldProcessHoldAttack(CameraAbilityPossess possess)
		{
			if ((Object)(object)possess == (Object)null || !possess.IsPossessing || (Object)(object)possess.currentUnit == (Object)null)
			{
				return false;
			}
			if (PossessionFreeAimLogic.IsSandboxPlacement())
			{
				return false;
			}
			return BattleStateHelper.IsBattleActive();
		}

		internal static bool ShouldSkipLateUpdateHold(CameraAbilityPossess possess, Unit unit)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Invalid comparison between Unknown and I4
			if ((Object)(object)possess == (Object)null || (Object)(object)unit == (Object)null)
			{
				return false;
			}
			if ((int)possess.cameraMode != 1)
			{
				return false;
			}
			FPSWeapon val = ((Component)unit).GetComponentInChildren<PlayerWeaponHandler>()?.fpsWeapon;
			if ((Object)(object)val != (Object)null && (Object)(object)val.rangeWeapon != (Object)null)
			{
				return (int)val.rangeWeaponType == 0;
			}
			return false;
		}

		internal static void TryProcessHoldAttacks(CameraAbilityPossess possess)
		{
			if (!ShouldProcessHoldAttack(possess) || IsPaused(possess) || ShouldSkipLateUpdateHold(possess, possess.currentUnit))
			{
				return;
			}
			WeaponHandler componentInChildren = ((Component)possess.currentUnit).GetComponentInChildren<WeaponHandler>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return;
			}
			DataHandler data = possess.currentUnit.data;
			object obj = PlayerCameraField?.GetValue(possess);
			if (obj == null)
			{
				return;
			}
			object? obj2 = AccessTools.Property(obj.GetType(), "Actions")?.GetValue(obj);
			PlayerActions val = (PlayerActions)((obj2 is PlayerActions) ? obj2 : null);
			if (val == null)
			{
				return;
			}
			object? obj3 = PossessionCameraField?.GetValue(possess);
			Component val2 = (Component)((obj3 is Component) ? obj3 : null);
			if (val2 != null)
			{
				object? obj4 = CamField?.GetValue(possess);
				Transform val3 = (Transform)((obj4 is Transform) ? obj4 : null);
				if (val3 != null)
				{
					object? obj5 = TargetRigField?.GetValue(possess);
					Rigidbody targetRig = (Rigidbody)((obj5 is Rigidbody) ? obj5 : null);
					bool autoShootEnabled = PossessionAutoShootStore.IsEnabled(data) && AimExclusionStore.ShouldShowAutoShootToggle(data);
					TryHoldAttackHand(val.m_possessAttack2, componentInChildren, data, val3, val2.transform, targetRig, (ForceWeapon)2, autoShootEnabled);
					TryHoldAttackHand(val.m_possessAttack1, componentInChildren, data, val3, val2.transform, targetRig, (ForceWeapon)1, autoShootEnabled);
				}
			}
		}

		private static void TryHoldAttackHand(PlayerAction action, WeaponHandler handler, DataHandler data, Transform cam, Transform possessionCamera, Rigidbody targetRig, ForceWeapon forceWeapon, bool autoShootEnabled)
		{
			//IL_0019: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)handler == (Object)null)
			{
				return;
			}
			if (action == null || !((OneAxisInputControl)action).IsPressed || !TryResolveHoldWeapon(handler, forceWeapon, out var weapon))
			{
				return;
			}
			if (autoShootEnabled && weapon.isRange && QualifiesForHoldAttack(weapon, handler))
			{
				if (IsPrimaryHandForWeapon(handler, forceWeapon, weapon) && !weapon.IsOnCooldown())
				{
					RangeWeapon val = (RangeWeapon)(object)((weapon is RangeWeapon) ? weapon : null);
					if (val == null || !PossessionMagazineLogic.IsWeaponReloading(val))
					{
						float maxRange = weapon.maxRange;
						Vector3 val2 = possessionCamera.position + cam.forward * maxRange;
						handler.Attack(val2, targetRig, cam.forward, forceWeapon);
					}
				}
			}
			else if ((!weapon.isRange || autoShootEnabled) && QualifiesForHoldAttack(weapon, handler) && !((OneAxisInputControl)action).WasPressed)
			{
				float maxRange2 = weapon.maxRange;
				Vector3 val3 = possessionCamera.position + cam.forward * maxRange2;
				handler.Attack(val3, targetRig, cam.forward, forceWeapon);
			}
		}

		private static bool IsPrimaryHandForWeapon(WeaponHandler handler, ForceWeapon forceWeapon, Weapon weapon)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			if ((Object)(object)handler == (Object)null || (Object)(object)weapon == (Object)null)
			{
				return false;
			}
			Weapon rightWeapon = handler.rightWeapon;
			Weapon leftWeapon = handler.leftWeapon;
			if ((Object)(object)rightWeapon != (Object)null && (Object)(object)leftWeapon != (Object)null)
			{
				Weapon val = (((int)forceWeapon == 2) ? rightWeapon : leftWeapon);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				return (Object)(object)(val.GetBestWeaponOnWeapon() ?? val) == (Object)(object)weapon;
			}
			if ((Object)(object)rightWeapon != (Object)null)
			{
				return true;
			}
			return (Object)(object)leftWeapon != (Object)null;
		}

		internal static bool TryResolveHoldWeapon(WeaponHandler handler, ForceWeapon forceWeapon, out Weapon weapon)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			weapon = null;
			if ((Object)(object)handler == (Object)null)
			{
				return false;
			}
			Weapon leftWeapon = handler.leftWeapon;
			Weapon rightWeapon = handler.rightWeapon;
			if ((Object)(object)leftWeapon == (Object)null && (Object)(object)rightWeapon == (Object)null)
			{
				return false;
			}
			if ((Object)(object)leftWeapon == (Object)null)
			{
				weapon = rightWeapon;
			}
			else if ((Object)(object)rightWeapon == (Object)null)
			{
				weapon = leftWeapon;
			}
			else
			{
				weapon = (((int)forceWeapon == 2) ? rightWeapon : leftWeapon);
			}
			Weapon obj = weapon;
			weapon = ((obj != null) ? obj.GetBestWeaponOnWeapon() : null) ?? weapon;
			return (Object)(object)weapon != (Object)null;
		}

		private static bool IsPaused(CameraAbilityPossess possess)
		{
			if (TimeServiceField?.GetValue(possess) == null)
			{
				return false;
			}
			MethodInfo methodInfo = AccessTools.Method(TimeServiceField.FieldType, "IsPaused", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				return (bool)methodInfo.Invoke(TimeServiceField.GetValue(possess), null);
			}
			return false;
		}
	}
	internal static class PossessionHoldAttackPatches
	{
		private static readonly FieldInfo SwingField = AccessTools.Field(typeof(PlayerWeaponHandler), "swing");

		private static readonly FieldInfo InputField = AccessTools.Field(typeof(PlayerWeaponHandler), "input");

		internal static void LateUpdate_Postfix(CameraAbilityPossess __instance)
		{
			PossessionHoldAttack.TryProcessHoldAttacks(__instance);
		}

		internal static void PlayerWeaponHandler_Update_Postfix(PlayerWeaponHandler __instance)
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Invalid comparison between Unknown and I4
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.fpsWeapon == (Object)null)
			{
				return;
			}
			CameraAbilityPossess val = FindPossessForUnit(((Component)((Component)__instance).transform.root).GetComponentInChildren<Unit>());
			if (!PossessionHoldAttack.ShouldProcessHoldAttack(val) || (Object)(object)val.currentUnit == (Object)null || (Object)(object)((Component)__instance).transform.root != (Object)(object)((Component)val.currentUnit).transform.root)
			{
				return;
			}
			FPSWeapon fpsWeapon = __instance.fpsWeapon;
			if ((Object)(object)fpsWeapon.meleeWeapon == (Object)null || (Object)(object)fpsWeapon.rangeWeapon != (Object)null)
			{
				return;
			}
			WeaponHandler componentInChildren = ((Component)val.currentUnit).GetComponentInChildren<WeaponHandler>();
			MeleeWeapon meleeWeapon = fpsWeapon.meleeWeapon;
			Weapon val2 = (Weapon)(((object)((meleeWeapon != null) ? ((Weapon)meleeWeapon).GetBestWeaponOnWeapon() : null)) ?? ((object)fpsWeapon.meleeWeapon));
			if (!PossessionHoldAttack.QualifiesForHoldAttack(val2, componentInChildren))
			{
				return;
			}
			object? obj = SwingField?.GetValue(__instance);
			SwingHandler val3 = (SwingHandler)((obj is SwingHandler) ? obj : null);
			if (val3 != null)
			{
				object? obj2 = InputField?.GetValue(__instance);
				PlayerInput val4 = (PlayerInput)((obj2 is PlayerInput) ? obj2 : null);
				if (val4 != null && val4.mouse0IsPressed && !val4.mouse0WasPressed && !val4.mouse0WasReleased && !val3.IsSwinging && (int)val3.holdDirection != 4 && !val2.IsOnCooldown())
				{
					val3.StartSwing(fpsWeapon);
					fpsWeapon.Swing();
				}
			}
		}

		private static CameraAbilityPossess FindPossessForUnit(Unit unit)
		{
			if ((Object)(object)unit == (Object)null)
			{
				return null;
			}
			if ((Object)(object)MainCam.instance != (Object)null)
			{
				CameraAbilityPossess val = ((Component)MainCam.instance).GetComponentInParent<CameraAbilityPossess>() ?? ((Component)MainCam.instance).GetComponentInChildren<CameraAbilityPossess>();
				if ((Object)(object)val != (Object)null && val.IsPossessing && (Object)(object)val.currentUnit == (Object)(object)unit)
				{
					return val;
				}
			}
			CameraAbilityPossess[] array = Object.FindObjectsOfType<CameraAbilityPossess>();
			foreach (CameraAbilityPossess val2 in array)
			{
				if ((Object)(object)val2 != (Object)null && val2.IsPossessing && (Object)(object)val2.currentUnit == (Object)(object)unit)
				{
					return val2;
				}
			}
			return null;
		}
	}
	internal static class PossessionHomingPatches
	{
		internal static bool SpellTarget_GetTarget_Prefix(SpellTarget __instance)
		{
			TeamHolder component = ((Component)__instance).GetComponent<TeamHolder>();
			if ((Object)(object)component?.spawner == (Object)null)
			{
				return true;
			}
			if (!PossessionBallisticAim.ShouldApplyCrosshairHomingForSpawner(component.spawner.GetComponentInChildren<DataHandler>()))
			{
				return true;
			}
			return false;
		}

		internal static void SpellTarget_Release_Postfix(SpellTarget __instance)
		{
			if (PossessionFreeAimLogic.ShouldRunPossessionFeatures())
			{
				PossessionBallisticAim.ReleaseHomingTracker(__instance.rig);
			}
		}
	}
	internal readonly struct PossessionMagazineDisplay
	{
		internal string Text { get; }

		internal bool IsReloading { get; }

		internal PossessionMagazineDisplay(string text, bool isReloading)
		{
			Text = text;
			IsReloading = isReloading;
		}
	}
	internal static class PossessionMagazineLogic
	{
		private static readonly FieldInfo ReloadingField = AccessTools.Field(typeof(RangeWeapon), "reloading");

		private static readonly Dictionary<RangeWeapon, float> ReloadStartTimes = new Dictionary<RangeWeapon, float>();

		private static readonly Dictionary<RangeWeapon, int> LastAmmo = new Dictionary<RangeWeapon, int>();

		private static readonly List<RangeWeapon> _scratchWeapons = new List<RangeWeapon>();

		internal static bool IsMagWeapon(RangeWeapon weapon)
		{
			RangeWeapon val = ResolveMagWeapon(weapon);
			if (val != null)
			{
				return val.magSize > 1;
			}
			return false;
		}

		internal static bool IsWeaponReloading(RangeWeapon weapon)
		{
			return IsReloading(ResolveMagWeapon(weapon));
		}

		internal static void OnReloadStarted(RangeWeapon weapon)
		{
			weapon = ResolveMagWeapon(weapon);
			if (!((Object)(object)weapon == (Object)null) && !(weapon.reloadTime <= 0f))
			{
				ReloadStartTimes[weapon] = Time.unscaledTime;
			}
		}

		internal static void ClearReloadTracking()
		{
			ReloadStartTimes.Clear();
			LastAmmo.Clear();
		}

		internal static void UpdateTrackedWeapons(RangeWeapon leftWeapon, RangeWeapon rightWeapon)
		{
			if ((Object)(object)leftWeapon != (Object)null)
			{
				TrackWeapon(leftWeapon);
			}
			if ((Object)(object)rightWeapon != (Object)null && (Object)(object)rightWeapon != (Object)(object)leftWeapon)
			{
				TrackWeapon(rightWeapon);
			}
		}

		internal static void OnProjectileFired(RangeWeapon weapon)
		{
			TrackWeapon(weapon, forceReloadCheck: true);
		}

		private static void TrackWeapon(RangeWeapon weapon, bool forceReloadCheck = false)
		{
			weapon = ResolveMagWeapon(weapon);
			if (IsMagWeapon(weapon))
			{
				int ammo = weapon.GetAmmo();
				if ((forceReloadCheck || (LastAmmo.TryGetValue(weapon, out var value) && value > 0 && ammo <= 0 && !IsReloading(weapon))) && ammo <= 0 && !IsReloading(weapon))
				{
					BeginReload(weapon);
				}
				LastAmmo[weapon] = ammo;
			}
		}

		private static void BeginReload(RangeWeapon weapon)
		{
			weapon = ResolveMagWeapon(weapon);
			if (!((Object)(object)weapon == (Object)null) && !(weapon.reloadTime <= 0f) && !IsReloading(weapon))
			{
				OnReloadStarted(weapon);
				weapon.Reload();
			}
		}

		internal static void PruneReloadTracking()
		{
			if (ReloadStartTimes.Count == 0 && LastAmmo.Count == 0)
			{
				return;
			}
			_scratchWeapons.Clear();
			foreach (KeyValuePair<RangeWeapon, float> reloadStartTime in ReloadStartTimes)
			{
				if ((Object)(object)reloadStartTime.Key == (Object)null)
				{
					_scratchWeapons.Add(reloadStartTime.Key);
					continue;
				}
				int ammo = reloadStartTime.Key.GetAmmo();
				if (!IsReloading(reloadStartTime.Key) && ammo > 0)
				{
					_scratchWeapons.Add(reloadStartTime.Key);
				}
			}
			for (int i = 0; i < _scratchWeapons.Count; i++)
			{
				ReloadStartTimes.Remove(_scratchWeapons[i]);
			}
			_scratchWeapons.Clear();
			foreach (KeyValuePair<RangeWeapon, int> item in LastAmmo)
			{
				if ((Object)(object)item.Key == (Object)null)
				{
					_scratchWeapons.Add(item.Key);
				}
			}
			for (int j = 0; j < _scratchWeapons.Count; j++)
			{
				LastAmmo.Remove(_scratchWeapons[j]);
			}
			_scratchWeapons.Clear();
		}

		internal static bool TryGetDisplay(RangeWeapon weapon, out PossessionMagazineDisplay display)
		{
			display = default(PossessionMagazineDisplay);
			weapon = ResolveMagWeapon(weapon);
			if ((Object)(object)weapon == (Object)null || weapon.magSize <= 1)
			{
				return false;
			}
			int ammo = weapon.GetAmmo();
			if (ammo <= 0 || IsReloading(weapon))
			{
				int num = Mathf.Max(1, Mathf.CeilToInt(GetReloadSecondsRemaining(weapon)));
				display = new PossessionMagazineDisplay($"Reloading: {num}", isReloading: true);
				return true;
			}
			display = new PossessionMagazineDisplay($"Ammo: {ammo}/{weapon.magSize}", isReloading: false);
			return true;
		}

		private static RangeWeapon ResolveMagWeapon(RangeWeapon weapon)
		{
			if ((Object)(object)weapon == (Object)null)
			{
				return null;
			}
			Weapon bestWeaponOnWeapon = ((Weapon)weapon).GetBestWeaponOnWeapon();
			return (RangeWeapon)(((object)((bestWeaponOnWeapon is RangeWeapon) ? bestWeaponOnWeapon : null)) ?? ((object)weapon));
		}

		private static bool IsReloading(RangeWeapon weapon)
		{
			weapon = ResolveMagWeapon(weapon);
			if ((Object)(object)weapon == (Object)null || ReloadingField == null)
			{
				return false;
			}
			object value = ReloadingField.GetValue(weapon);
			bool flag = default(bool);
			int num;
			if (value is bool)
			{
				flag = (bool)value;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}

		private static float GetReloadSecondsRemaining(RangeWeapon weapon)
		{
			weapon = ResolveMagWeapon(weapon);
			if ((Object)(object)weapon == (Object)null)
			{
				return 0f;
			}
			if (!ReloadStartTimes.TryGetValue(weapon, out var value))
			{
				if (IsReloading(weapon))
				{
					ReloadStartTimes[weapon] = Time.unscaledTime;
					return weapon.reloadTime;
				}
				return weapon.reloadTime;
			}
			return Mathf.Max(0f, weapon.reloadTime - (Time.unscaledTime - value));
		}
	}
	internal static class PossessionMagazinePatches
	{
		[HarmonyPrefix]
		internal static void RangeWeapon_Reload_Prefix(RangeWeapon __instance)
		{
			PossessionMagazineLogic.OnReloadStarted(__instance);
		}

		[HarmonyPostfix]
		internal static void RangeWeapon_SetProjectileStats_Postfix(RangeWeapon __instance)
		{
			PossessionMagazineLogic.OnProjectileFired(__instance);
		}
	}
	internal sealed class PossessionMagazineUi : MonoBehaviour
	{
		private static readonly FieldInfo PossessUiField = AccessTools.Field(typeof(CameraAbilityPossess), "possessUI");

		private static readonly FieldInfo LeftWeaponField = AccessTools.Field(typeof(CameraAbilityPossessUI), "leftW");

		private static readonly FieldInfo RightWeaponField = AccessTools.Field(typeof(CameraAbilityPossessUI), "rightW");

		private GUIStyle _labelStyle;

		private GUIStyle _reloadStyle;

		private GUIStyle _labelShadowStyle;

		private GUIStyle _reloadShadowStyle;

		private void LateUpdate()
		{
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures() || !PossessionFreeAimLogic.ShouldApply())
			{
				return;
			}
			CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
			if (!((Object)(object)possess == (Object)null) && possess.IsPossessing && !((Object)(object)possess.currentUnit == (Object)null))
			{
				WeaponHandler componentInChildren = ((Component)possess.currentUnit).GetComponentInChildren<WeaponHandler>();
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					Weapon leftWeapon = componentInChildren.leftWeapon;
					Weapon leftWeapon2 = ((leftWeapon is RangeWeapon) ? leftWeapon : null);
					Weapon rightWeapon = componentInChildren.rightWeapon;
					PossessionMagazineLogic.UpdateTrackedWeapons((RangeWeapon)(object)leftWeapon2, (RangeWeapon)(object)((rightWeapon is RangeWeapon) ? rightWeapon : null));
					PossessionMagazineLogic.PruneReloadTracking();
				}
			}
		}

		private void OnGUI()
		{
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures() || !PossessionFreeAimLogic.ShouldApply())
			{
				return;
			}
			CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
			if ((Object)(object)possess == (Object)null || !possess.IsPossessing || (Object)(object)possess.currentUnit == (Object)null)
			{
				return;
			}
			object? obj = PossessUiField?.GetValue(possess);
			CameraAbilityPossessUI val = (CameraAbilityPossessUI)((obj is CameraAbilityPossessUI) ? obj : null);
			if (val == null || !val.UIActive)
			{
				return;
			}
			WeaponHandler componentInChildren = ((Component)possess.currentUnit).GetComponentInChildren<WeaponHandler>();
			if (!((Object)(object)componentInChildren == (Object)null))
			{
				EnsureStyles();
				Weapon leftWeapon = componentInChildren.leftWeapon;
				RangeWeapon val2 = (RangeWeapon)(object)((leftWeapon is RangeWeapon) ? leftWeapon : null);
				Weapon rightWeapon = componentInChildren.rightWeapon;
				RangeWeapon val3 = (RangeWeapon)(object)((rightWeapon is RangeWeapon) ? rightWeapon : null);
				PossessionMagazineLogic.UpdateTrackedWeapons(val2, val3);
				object? obj2 = LeftWeaponField?.GetValue(val);
				GameObject val4 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				object? obj3 = RightWeaponField?.GetValue(val);
				GameObject val5 = (GameObject)((obj3 is GameObject) ? obj3 : null);
				if ((Object)(object)val2 != (Object)null && (Object)(object)val4 != (Object)null && val4.activeInHierarchy && PossessionMagazineLogic.TryGetDisplay(val2, out var display))
				{
					DrawLabel(val4, display, placeOnLeft: true);
				}
				if ((Object)(object)val3 != (Object)null && (Object)(object)val5 != (Object)null && val5.activeInHierarchy && PossessionMagazineLogic.TryGetDisplay(val3, out var display2))
				{
					DrawLabel(val5, display2, placeOnLeft: false);
				}
			}
		}

		private void DrawLabel(GameObject anchor, PossessionMagazineDisplay display, bool placeOnLeft)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//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_0047: 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_0053: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)anchor == (Object)null) && !string.IsNullOrEmpty(display.Text))
			{
				GUIStyle val = (display.IsReloading ? _reloadStyle : _labelStyle);
				GUIContent val2 = new GUIContent(display.Text);
				Vector2 labelSize = val.CalcSize(val2);
				if (TryGetScreenRectBeside(anchor, placeOnLeft, labelSize, out var rect))
				{
					Rect val3 = rect;
					((Rect)(ref val3)).x = ((Rect)(ref val3)).x + 1f;
					((Rect)(ref val3)).y = ((Rect)(ref val3)).y + 1f;
					GUIStyle val4 = (display.IsReloading ? _reloadShadowStyle : _labelShadowStyle);
					GUI.Label(val3, val2, val4);
					GUI.Label(rect, val2, val);
				}
			}
		}

		private static bool TryGetScreenRectBeside(GameObject anchor, bool placeOnLeft, Vector2 labelSize, out Rect rect)
		{
			//IL_0001: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_005d: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			rect = default(Rect);
			if ((Object)(object)anchor == (Object)null)
			{
				return false;
			}
			Transform transform = anchor.transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Canvas componentInParent = anchor.GetComponentInParent<Canvas>();
			Camera obj = (((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0) ? componentInParent.worldCamera : null);
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			val.GetWorldCorners(array);
			Vector3 val2 = (placeOnLeft ? ((array[0] + array[1]) * 0.5f) : ((array[2] + array[3]) * 0.5f));
			Vector2 val3 = RectTransformUtility.WorldToScreenPoint(obj, val2);
			val3.y = (float)Screen.height - val3.y;
			rect = new Rect(placeOnLeft ? (val3.x - labelSize.x - 8f) : (val3.x + 8f), val3.y - labelSize.y * 0.5f - 22f, labelSize.x, labelSize.y);
			return true;
		}

		private void EnsureStyles()
		{
			//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_0026: Expected O, but got Unknown
			//IL_0045: 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_0060: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			if (_labelStyle == null)
			{
				_labelStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 15
				};
				_labelStyle.normal.textColor = new Color(0.95f, 0.98f, 1f, 0.98f);
				_reloadStyle = new GUIStyle(_labelStyle);
				_reloadStyle.normal.textColor = new Color(1f, 0.35f, 0.35f, 0.98f);
				_labelShadowStyle = new GUIStyle(_labelStyle);
				_labelShadowStyle.normal.textColor = new Color(0f, 0f, 0f, 0.65f);
				_reloadShadowStyle = new GUIStyle(_reloadStyle);
				_reloadShadowStyle.normal.textColor = new Color(0f, 0f, 0f, 0.65f);
			}
		}
	}
	internal static class PossessionMeleeDashLogic
	{
		private static readonly Dictionary<int, Vector3> DashAttackPointByHandler = new Dictionary<int, Vector3>();

		internal static bool ShouldUseMeleeDash(DataHandler data)
		{
			if ((Object)(object)data == (Object)null || !AimExclusionStore.ShouldUseMeleeDash(data))
			{
				return false;
			}
			if (BattleMeleeDashStore.IsDisabled(data))
			{
				return false;
			}
			return AimExclusionStore.ShouldUseCrosshairAim(data);
		}

		internal static bool ShouldSuppressMeleeDashEffects(DataHandler data)
		{
			if ((Object)(object)data != (Object)null && PossessionFreeAimLogic.IsPossessedUnit(data) && AimExclusionStore.ShouldUseMeleeDash(data))
			{
				return BattleMeleeDashStore.IsDisabled(data);
			}
			return false;
		}

		internal static void StashDashAttackPoint(DataHandler data, Vector3 attackPoint)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)data == (Object)null))
			{
				DashAttackPointByHandler[((Object)data).GetInstanceID()] = attackPoint;
			}
		}

		internal static bool TryGetStashedDashAttackPoint(DataHandler data, out Vector3 attackPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			attackPoint = default(Vector3);
			if ((Object)(object)data == (Object)null)
			{
				return false;
			}
			return DashAttackPointByHandler.TryGetValue(((Object)data).GetInstanceID(), out attackPoint);
		}

		internal static void ClearDashAttackPoint(DataHandler data)
		{
			if (!((Object)(object)data == (Object)null))
			{
				DashAttackPointByHandler.Remove(((Object)data).GetInstanceID());
			}
		}

		internal static bool TryGetCrosshairMeleeAttackPoint(DataHandler data, out Vector3 attackPoint, out Vector3 aimDirection, out PossessionCrosshairAim.AimTarget aimTarget)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0053: 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_0058: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00d2: 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_0091: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			attackPoint = default(Vector3);
			aimDirection = default(Vector3);
			aimTarget = default(PossessionCrosshairAim.AimTarget);
			if ((Object)(object)data == (Object)null)
			{
				return false;
			}
			if (!PossessionFreeAimLogic.TryGetCameraAim(out var aim, out var _))
			{
				return false;
			}
			Vector3 aimOrigin = PossessionCrosshairAim.GetAimOrigin(data);
			float aimDistanceForHandler = PossessionCrosshairAim.GetAimDistanceForHandler(data);
			aimDirection = ((((Vector3)(ref aim)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref aim)).normalized : Vector3.forward);
			if (PossessionCrosshairAim.TryGetCrosshairAimPoint(aimDistanceForHandler, out attackPoint, out aimTarget, allowSoftTargets: true))
			{
				if ((Object)(object)aimTarget.MainRig != (Object)null && PossessionCrosshairAim.TryGetPossessionCamera(out var camera, out var _))
				{
					Ray ray = default(Ray);
					((Ray)(ref ray))..ctor(((Component)camera).transform.position, aimDirection);
					attackPoint = PossessionCrosshairAim.ProjectOntoCrosshairRay(ray, attackPoint);
				}
				Vector3 val = attackPoint - aimOrigin;
				if (((Vector3)(ref val)).sqrMagnitude > 0.01f)
				{
					aimDirection = ((Vector3)(ref val)).normalized;
				}
				return true;
			}
			attackPoint = aimOrigin + aimDirection * Mathf.Max(4f, aimDistanceForHandler);
			return true;
		}

		internal static void TryTriggerFpsMeleeDash(FPSWeapon fpsWeapon)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures())
			{
				return;
			}
			MeleeWeapon val = fpsWeapon?.meleeWeapon;
			DataHandler data = ((val != null) ? ((Weapon)val).connectedData : null);
			if ((Object)(object)val == (Object)null || !ShouldUseMeleeDash(data) || !PossessionFreeAimLogic.IsPossessedUnit(data))
			{
				return;
			}
			if (!TryGetCrosshairMeleeAttackPoint(data, out var attackPoint, out var aimDirection, out var _))
			{
				float aimDistanceForHandler = PossessionCrosshairAim.GetAimDistanceForHandler(data);
				if (!PossessionCrosshairAim.TryGetAimDirection(data, aimDistanceForHandler, out aimDirection, out attackPoint))
				{
					return;
				}
			}
			StashDashAttackPoint(data, attackPoint);
			AttackEffect[] attackEffects = ((Weapon)val).attackEffects;
			if (attackEffects == null || attackEffects.Length == 0)
			{
				return;
			}
			foreach (AttackEffect obj in attackEffects)
			{
				if (obj != null)
				{
					obj.DoEffect((Rigidbody)null, Vector3.forward);
				}
			}
		}

		internal static void ApplyMeleeAttackAim(ref Rigidbody targetRig, ref Vector3 forcedDirection, DataHandler data)
		{
			//IL_0022: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)data == (Object)null))
			{
				if (!TryGetCrosshairMeleeAttackPoint(data, out var attackPoint, out var aimDirection, out var _))
				{
					PossessionFreeAimLogic.ApplyAttackAim(ref targetRig, ref forcedDirection);
					return;
				}
				StashDashAttackPoint(data, attackPoint);
				forcedDirection = aimDirection;
				targetRig = null;
			}
		}

		internal static bool TryAdjustDashEffectDirection(DataHandler data, Transform effectTransform, ref Vector3 targetDir)
		{
			//IL_0021: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)data == (Object)null || (Object)(object)effectTransform == (Object)null)
			{
				return false;
			}
			if (!TryGetStashedDashAttackPoint(data, out var attackPoint))
			{
				return false;
			}
			targetDir = attackPoint - effectTransform.position;
			return ((Vector3)(ref targetDir)).sqrMagnitude > 0.0001f;
		}
	}
	internal static class PossessionMeleeDashPatches
	{
		public static void StartSwing_Postfix(FPSWeapon fpsWeapon)
		{
			PossessionMeleeDashLogic.TryTriggerFpsMeleeDash(fpsWeapon);
		}

		public static void MeleeWeapon_Attack_Prefix(MeleeWeapon __instance, ref bool? __state)
		{
			__state = null;
			if (PossessionMeleeDashLogic.ShouldSuppressMeleeDashEffects((__instance != null) ? ((Weapon)__instance).connectedData : null))
			{
				__state = ((Weapon)__instance).callAttackEffects;
				((Weapon)__instance).callAttackEffects = false;
			}
		}

		public static void MeleeWeapon_Attack_Postfix(MeleeWeapon __instance, bool? __state)
		{
			PossessionMeleeDashLogic.ClearDashAttackPoint((__instance != null) ? ((Weapon)__instance).connectedData : null);
			if (__state.HasValue)
			{
				((Weapon)__instance).callAttackEffects = __state.Value;
			}
		}

		public static void WeaponForceAnimation_DoEffect_Prefix(WeaponForceAnimation __instance, Rigidbody target, ref Vector3 targetDir)
		{
			if (!((Object)(object)target != (Object)null))
			{
				object obj;
				if (__instance == null)
				{
					obj = null;
				}
				else
				{
					Weapon componentInParent = ((Component)__instance).GetComponentInParent<Weapon>();
					obj = ((componentInParent != null) ? componentInParent.connectedData : null);
				}
				DataHandler val = (DataHandler)obj;
				if (!((Object)(object)val == (Object)null) && PossessionMeleeDashLogic.ShouldUseMeleeDash(val))
				{
					PossessionMeleeDashLogic.TryAdjustDashEffectDirection(val, ((Component)__instance).transform, ref targetDir);
				}
			}
		}
	}
	internal static class PossessionMouseLookPatches
	{
		private static readonly FieldInfo SensitivityField = AccessTools.Field(typeof(MouseLook), "m_sensitivity");

		private static readonly Dictionary<MouseLook, float> SavedSensitivity = new Dictionary<MouseLook, float>();

		public static void Update_Prefix(MouseLook __instance)
		{
			if (PossessionFreeAimLogic.ShouldRunPossessionFeatures() && FirstPersonFreeAimConfig.Enabled && !(SensitivityField == null) && ShouldScaleLook(__instance))
			{
				float lookSensitivityScale = PossessionZoom.GetLookSensitivityScale();
				if (!Mathf.Approximately(lookSensitivityScale, 1f))
				{
					float num = (float)SensitivityField.GetValue(__instance);
					SavedSensitivity[__instance] = num;
					SensitivityField.SetValue(__instance, num * lookSensitivityScale);
				}
			}
		}

		public static void Update_Postfix(MouseLook __instance)
		{
			if (PossessionFreeAimLogic.ShouldRunPossessionFeatures() && SavedSensitivity.TryGetValue(__instance, out var value))
			{
				SensitivityField?.SetValue(__instance, value);
				SavedSensitivity.Remove(__instance);
			}
		}

		internal static void ResetSavedSensitivity()
		{
			SavedSensitivity.Clear();
		}

		private static bool ShouldScaleLook(MouseLook mouseLook)
		{
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures())
			{
				return false;
			}
			CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
			if (PossessionFreeAimLogic.IsSandboxPlacement())
			{
				return false;
			}
			if ((Object)(object)possess != (Object)null && possess.IsPossessing && (Object)(object)mouseLook != (Object)null)
			{
				return ((Behaviour)mouseLook).enabled;
			}
			return false;
		}
	}
	internal static class PossessionPossessInputPatches
	{
		private sealed class CounterBackup
		{
			internal float Counter;

			internal Weapon Weapon;
		}

		[HarmonyPriority(800)]
		internal static void WeaponHandler_Attack_BackupCounter_Prefix(WeaponHandler __instance, ForceWeapon forceWeapon, ref object __state)
		{
			//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)
			__state = null;
			DataHandler handlerData = PossessionAttackRangeGate.GetHandlerData(__instance);
			if (PossessionAttackRangeGate.ShouldBlockHandlerAttack(__instance, handlerData, forceWeapon))
			{
				Weapon vanillaActiveWeapon = PossessionAttackRangeGate.GetVanillaActiveWeapon(__instance, forceWeapon);
				if (!((Object)(object)vanillaActiveWeapon == (Object)null))
				{
					__state = new CounterBackup
					{
						Counter = vanillaActiveWeapon.internalCounter,
						Weapon = vanillaActiveWeapon
					};
				}
			}
		}

		[HarmonyPriority(0)]
		internal static void WeaponHandler_Attack_RestoreCounter_Postfix(object __state)
		{
			if (__state is CounterBackup counterBackup && !((Object)(object)counterBackup.Weapon == (Object)null))
			{
				counterBackup.Weapon.internalCounter = counterBackup.Counter;
				Weapon weapon = counterBackup.Weapon;
				RangeWeapon val = (RangeWeapon)(object)((weapon is RangeWeapon) ? weapon : null);
				if (val != null)
				{
					PossessionProjectileAim.ClearWeapon(val);
				}
			}
		}

		[HarmonyPriority(800)]
		internal static bool RangeWeapon_Attack_BlockOutOfRange_Prefix(RangeWeapon __instance, bool recursive, ref object __state)
		{
			__state = null;
			if (recursive)
			{
				return true;
			}
			if (!PossessionAttackRangeGate.IsGateActive((__instance != null) ? ((Weapon)__instance).connectedData : null) || PossessionAttackRangeGate.CanAttack(((Weapon)__instance).connectedData, (Weapon)(object)__instance))
			{
				return true;
			}
			__state = new CounterBackup
			{
				Counter = ((Weapon)__instance).internalCounter,
				Weapon = (Weapon)(object)__instance
			};
			return false;
		}

		[HarmonyPriority(0)]
		internal static void RangeWeapon_Attack_RestoreCounter_Postfix(object __state)
		{
			if (__state is CounterBackup counterBackup)
			{
				Weapon weapon = counterBackup.Weapon;
				RangeWeapon val = (RangeWeapon)(object)((weapon is RangeWeapon) ? weapon : null);
				if (val != null)
				{
					((Weapon)val).internalCounter = counterBackup.Counter;
					PossessionProjectileAim.ClearWeapon(val);
				}
			}
		}
	}
	internal static class PossessionProjectileAim
	{
		private sealed class VolleySpreadState
		{
			public float WeaponSpread;

			public float ProjectileSprea;

			public float PrefabRandomRotation;

			public float SiblingSpread;

			public float AngularSpread;

			public float ProjectileSpeedSpread;

			public bool CaptureAttempted;
		}

		private readonly struct PrefabSpreadCacheEntry
		{
			public readonly float Sprea;

			public readonly float RandomRotation;

			public PrefabSpreadCacheEntry(float sprea, float randomRotation)
			{
				Sprea = sprea;
				RandomRotation = randomRotation;
			}
		}

		private static readonly Dictionary<int, PrefabSpreadCacheEntry> PrefabSpreadCache = new Dictionary<int, PrefabSpreadCacheEntry>();

		private static readonly FieldInfo ObjectToSpawnField = AccessTools.Field(typeof(RangeWeapon), "objectToSpawn");

		private static readonly Type RandomRotationType = AccessTools.TypeByName("RandomRotation, Assembly-CSharp");

		private static readonly FieldInfo RandomRotationSpreadField = ((RandomRotationType != null) ? AccessTools.Field(RandomRotationType, "spread") : null);

		private static readonly Dictionary<RangeWeapon, int> RemainingShots = new Dictionary<RangeWeapon, int>();

		private static readonly Dictionary<RangeWeapon, VolleySpreadState> SavedVolleySpread = new Dictionary<RangeWeapon, VolleySpreadState>();

		internal static void BeginWeaponVolley(RangeWeapon weapon)
		{
			if (!((Object)(object)weapon == (Object)null) && FirstPersonFreeAimConfig.Enabled && PossessionFreeAimLogic.IsPossessedUnit(((Weapon)weapon).connectedData) && AimExclusionStore.ShouldUseCrosshairAim(((Weapon)weapon).connectedData))
			{
				PossessionBallisticAim.ClearFrameAimCache(weapon);
				PossessionBallisticAim.BeginVolleyProjectilePatches(weapon);
				RemainingShots[weapon] = ((weapon.numberOfObjects <= 0) ? 1 : weapon.numberOfObjects);
				SaveVolleySpreadSnapshot(weapon);
			}
		}

		internal static bool TryGetVolleyAngularSpread(RangeWeapon weapon, out float angularSpread)
		{
			angularSpread = 0f;
			if ((Object)(object)weapon == (Object)null || !SavedVolleySpread.TryGetValue(weapon, out var value))
			{
				return false;
			}
			angularSpread = value.AngularSpread;
			return true;
		}

		internal static bool TryGetVolleySpeedSpread(RangeWeapon weapon, out float speedSpread)
		{
			speedSpread = 0f;
			if ((Object)(object)weapon == (Object)null || !SavedVolleySpread.TryGetValue(weapon, out var value))
			{
				return false;
			}
			speedSpread = value.ProjectileSpeedSpread;
			return true;
		}

		internal static void TryCaptureSpreadFromSpawnedProjectile(RangeWeapon weapon, GameObject spawnedObject)
		{
			if ((Object)(object)weapon == (Object)null || (Object)(object)spawnedObject == (Object)null || !SavedVolleySpread.TryGetValue(weapon, out var value) || value.AngularSpread > 0.01f || value.CaptureAttempted)
			{
				return;
			}
			value.CaptureAttempted = true;
			float num = 0f;
			float num2 = 0f;
			MoveTransform[] componentsInChildren = spawnedObject.GetComponentsInChildren<MoveTransform>(true);
			foreach (MoveTransform val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					num = Mathf.Max(num, val.sprea);
				}
			}
			num2 = GetMaxRandomRotationSpread(spawnedObject);
			float num3 = Mathf.Max(num, num2);
			if (!(num3 <= 0.01f))
			{
				value.ProjectileSprea = Mathf.Max(value.ProjectileSprea, num);
				value.PrefabRandomRotation = Mathf.Max(value.PrefabRandomRotation, num2);
				value.AngularSpread = num3;
			}
		}

		internal static void CompleteProjectile(RangeWeapon weapon)
		{
			if (!((Object)(object)weapon == (Object)null) && RemainingShots.TryGetValue(weapon, out var value))
			{
				value--;
				if (value <= 0)
				{
					RemainingShots.Remove(weapon);
					RestoreVolleySpread(weapon);
					PossessionBallisticAim.ClearFrameAimCache(weapon);
					PossessionBallisticAim.EndVolleyProjectilePatches(weapon);
				}
				else
				{
					RemainingShots[weapon] = value;
				}
			}
		}

		internal static void ClearWeapon(RangeWeapon weapon)
		{
			if (!((Object)(object)weapon == (Object)null))
			{
				RemainingShots.Remove(weapon);
				RestoreVolleySpread(weapon);
				PossessionBallisticAim.ClearFrameAimCache(weapon);
				PossessionBallisticAim.EndVolleyProjectilePatches(weapon);
			}
		}

		private static void SaveVolleySpreadSnapshot(RangeWeapon weapon)
		{
			GameObject objectToSpawn = GetObjectToSpawn(weapon);
			float spread = weapon.spread;
			(float sprea, float randomRotation) cachedPrefabSpread = GetCachedPrefabSpread(objectToSpawn);
			float item = cachedPrefabSpread.sprea;
			float item2 = cachedPrefabSpread.randomRotation;
			float siblingWeaponSpreadMax = GetSiblingWeaponSpreadMax(weapon);
			float num = Mathf.Max(new float[4] { spread, item, item2, siblingWeaponSpreadMax });
			SavedVolleySpread[weapon] = new VolleySpreadState
			{
				WeaponSpread = spread,
				ProjectileSprea = item,
				PrefabRandomRotation = item2,
				SiblingSpread = siblingWeaponSpreadMax,
				AngularSpread = num,
				ProjectileSpeedSpread = weapon.projectileSpeedSpread,
				CaptureAttempted = (num > 0.01f)
			};
		}

		private static (float sprea, float randomRotation) GetCachedPrefabSpread(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return (0f, 0f);
			}
			int instanceID = ((Object)prefab).GetInstanceID();
			if (PrefabSpreadCache.TryGetValue(instanceID, out var value))
			{
				return (value.Sprea, value.RandomRotation);
			}
			float maxMoveTransformSprea = GetMaxMoveTransformSprea(prefab);
			float maxRandomRotationSpread = GetMaxRandomRotationSpread(prefab);
			PrefabSpreadCache[instanceID] = new PrefabSpreadCacheEntry(maxMoveTransformSprea, maxRandomRotationSpread);
			return (maxMoveTransformSprea, maxRandomRotationSpread);
		}

		private static GameObject GetObjectToSpawn(RangeWeapon weapon)
		{
			if ((Object)(object)weapon == (Object)null)
			{
				return null;
			}
			if ((Object)(object)weapon.ObjectToSpawn != (Object)null)
			{
				return weapon.ObjectToSpawn;
			}
			object? obj = ObjectToSpawnField?.GetValue(weapon);
			return (GameObject)((obj is GameObject) ? obj : null);
		}

		private static float GetMaxMoveTransformSprea(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return 0f;
			}
			float num = 0f;
			MoveTransform[] componentsInChildren = prefab.GetComponentsInChildren<MoveTransform>(true);
			foreach (MoveTransform val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					num = Mathf.Max(num, val.sprea);
				}
			}
			return num;
		}

		private static float GetMaxRandomRotationSpread(GameObject root)
		{
			if ((Object)(object)root == (Object)null || RandomRotationType == null || RandomRotationSpreadField == null)
			{
				return 0f;
			}
			float num = 0f;
			Component[] componentsInChildren = root.GetComponentsInChildren(RandomRotationType, true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && RandomRotationSpreadField.GetValue(val) is float num2)
				{
					num = Mathf.Max(num, num2);
				}
			}
			return num;
		}

		private static float GetSiblingWeaponSpreadMax(RangeWeapon weapon)
		{
			WeaponHandler val = ((weapon == null) ? null : ((Weapon)weapon).connectedData?.weaponHandler);
			if ((Object)(object)val == (Object)null)
			{
				return 0f;
			}
			float num = 0f;
			Weapon leftWeapon = val.leftWeapon;
			RangeWeapon val2 = (RangeWeapon)(object)((leftWeapon is RangeWeapon) ? leftWeapon : null);
			if (val2 != null)
			{
				num = Mathf.Max(num, val2.spread);
			}
			Weapon rightWeapon = val.rightWeapon;
			RangeWeapon val3 = (RangeWeapon)(object)((rightWeapon is RangeWeapon) ? rightWeapon : null);
			if (val3 != null)
			{
				num = Mathf.Max(num, val3.spread);
			}
			return num;
		}

		private static void RestoreVolleySpread(RangeWeapon weapon)
		{
			if (SavedVolleySpread.TryGetValue(weapon, out var value))
			{
				weapon.spread = value.WeaponSpread;
				weapon.projectileSpeedSpread = value.ProjectileSpeedSpread;
				SavedVolleySpread.Remove(weapon);
			}
		}
	}
	internal static class PossessionRangedHold
	{
		private struct HoldPreset
		{
			internal Vector3 Forward;

			internal Vector3 Up;
		}

		private static readonly Dictionary<Holdable, HoldPreset> HoldablePresets = new Dictionary<Holdable, HoldPreset>();

		internal static void OnPossessEnter(Unit unit)
		{
			HoldablePresets.Clear();
			CachePresetsForUnit(unit);
		}

		internal static void CachePresetsForHandler(DataHandler handler)
		{
			CachePresetsForUnit(handler?.unit);
		}

		internal static void CachePresetsForUnit(Unit unit)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)unit == (Object)null)
			{
				return;
			}
			Holdable[] componentsInChildren = ((Component)unit).GetComponentsInChildren<Holdable>(true);
			foreach (Holdable val in componentsInChildren)
			{
				if (val?.holdableData != null)
				{
					HoldablePresets[val] = new HoldPreset
					{
						Forward = val.holdableData.forwardRotation,
						Up = val.holdableData.upRotation
					};
				}
			}
		}

		internal static void OnPossessExit()
		{
			//IL_0038: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<Holdable, HoldPreset> holdablePreset in HoldablePresets)
			{
				Holdable key = holdablePreset.Key;
				if (key?.holdableData != null)
				{
					key.holdableData.forwardRotation = holdablePreset.Value.Forward;
					key.holdableData.upRotation = holdablePreset.Value.Up;
					if ((Object)(object)key.rig != (Object)null)
					{
						key.rig.angularVelocity = Vector3.zero;
					}
				}
			}
			HoldablePresets.Clear();
		}

		internal static bool IsRangedHoldable(Holdable holdable)
		{
			if ((Object)(object)holdable == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)((Component)holdable).GetComponentInChildren<RangeWeapon>(true) != (Object)null))
			{
				return (Object)(object)((Component)holdable).GetComponentInChildren<ShootPosition>(true) != (Object)null;
			}
			return true;
		}

		internal static bool IsRangedFpsWeapon(FPSWeapon weapon)
		{
			if ((Object)(object)weapon == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)weapon.rangeWeapon != (Object)null))
			{
				return (Object)(object)((Component)weapon).GetComponentInChildren<ShootPosition>(true) != (Object)null;
			}
			return true;
		}

		internal static bool TryApplyTiltedHold(Holdable holdable, DataHandler handler, Vector3 aim, HoldableDataInstance holdableData)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_005f: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00ce: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			if (!IsRangedHoldable(holdable) || holdableData == null || (Object)(object)handler?.characterForwardObject == (Object)null)
			{
				return false;
			}
			if (((Vector3)(ref aim)).sqrMagnitude < 0.0001f)
			{
				return false;
			}
			if (!HoldablePresets.TryGetValue(holdable, out var value))
			{
				value.Forward = holdable.holdableData.forwardRotation;
				value.Up = holdable.holdableData.upRotation;
			}
			Transform characterForwardObject = handler.characterForwardObject;
			Vector3 forward = characterForwardObject.forward;
			if (((Vector3)(ref forward)).sqrMagnitude < 0.0001f)
			{
				return false;
			}
			Vector3 val = characterForwardObject.TransformDirection(value.Forward);
			Vector3 val2 = characterForwardObject.TransformDirection(value.Up);
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				return false;
			}
			Vector3 val3 = ((((Vector3)(ref val2)).sqrMagnitude > 0.0001f) ? val2 : Vector3.up);
			Quaternion val4 = Quaternion.FromToRotation(forward, aim);
			Vector3 val5 = val4 * val;
			Vector3 val6 = val4 * val3;
			holdableData.forwardRotation = characterForwardObject.InverseTransformDirection(val5);
			holdableData.upRotation = characterForwardObject.InverseTransformDirection(val6);
			return true;
		}
	}
	internal sealed class PossessionRangeUi : MonoBehaviour
	{
		private static readonly Color InRangeDotColor = new Color(0.85f, 1f, 0.85f, 0.95f);

		private static readonly Color OutOfRangeDotColor = new Color(1f, 0.25f, 0.25f, 0.75f);

		private static readonly FieldInfo PossessUiField = AccessTools.Field(typeof(CameraAbilityPossess), "possessUI");

		private GUIStyle _outOfRangeStyle;

		private Image _dotImage;

		private void LateUpdate()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures())
			{
				_dotImage = null;
				return;
			}
			if (!PossessionAttackRangeGate.IsEnabled || !PossessionFreeAimLogic.ShouldApply())
			{
				_dotImage = null;
				return;
			}
			CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
			Unit val = possess?.currentUnit;
			if ((Object)(object)possess != (Object)null && (int)possess.cameraMode == 1)
			{
				FPSWeapon val2 = TryGetFpsWeapon(possess);
				if (val2 != null)
				{
					PossessionAttackRangeGate.RefreshStateForFpsWeapon(val2);
					goto IL_0079;
				}
			}
			PossessionAttackRangeGate.RefreshState((val != null) ? ((Component)val).GetComponentInChildren<WeaponHandler>() : null, val?.data);
			goto IL_0079;
			IL_0079:
			UpdateDotTint(possess);
		}

		private void OnGUI()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (PossessionFreeAimLogic.ShouldRunPossessionFeatures() && PossessionFreeAimLogic.ShouldApply() && PossessionAttackRangeGate.IsEnabled && PossessionAttackRangeGate.LastState.GateActive)
			{
				float centerX = (float)Screen.width * 0.5f;
				float num = (float)Screen.height * 0.5f;
				PossessionAttackRangeGate.RangeGateState lastState = PossessionAttackRangeGate.LastState;
				DrawReticle(centerX, num, 10f, GetReticleColor(lastState));
				if (!lastState.CanAttack)
				{
					EnsureStyle();
					GUIContent val = new GUIContent("OUT OF RANGE");
					Vector2 val2 = _outOfRangeStyle.CalcSize(val);
					float num2 = ((float)Screen.width - val2.x) * 0.5f;
					float num3 = num + 24f;
					GUI.Label(new Rect(num2, num3, val2.x, val2.y), val, _outOfRangeStyle);
				}
			}
		}

		private static Color GetReticleColor(PossessionAttackRangeGate.RangeGateState state)
		{
			//IL_0023: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			if (PossessionAttackRangeGate.IsEnabled && state.GateActive)
			{
				if (!state.CanAttack)
				{
					return OutOfRangeDotColor;
				}
				return InRangeDotColor;
			}
			return InRangeDotColor;
		}

		private static void DrawReticle(float centerX, float centerY, float armLength, Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			Color color2 = GUI.color;
			GUI.color = color;
			float num = 2f;
			GUI.DrawTexture(new Rect(centerX - armLength, centerY - num * 0.5f, armLength * 2f, num), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(centerX - num * 0.5f, centerY - armLength, num, armLength * 2f), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color2;
		}

		internal static void UpdateCooldowns_Prefix(ref bool attackLeftIsActive, ref bool attackRightIsActive)
		{
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures() || !PossessionAttackRangeGate.IsEnabled)
			{
				return;
			}
			CameraAbilityPossess possess = PossessionFreeAimLogic.GetPossess();
			if ((Object)(object)possess == (Object)null || !possess.IsPossessing)
			{
				return;
			}
			Unit currentUnit = possess.currentUnit;
			WeaponHandler val = ((currentUnit != null) ? ((Component)currentUnit).GetComponentInChildren<WeaponHandler>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			PossessionAttackRangeGate.RefreshState(val, possess.currentUnit?.data);
			if (attackLeftIsActive || attackRightIsActive)
			{
				if (!PossessionAttackRangeGate.CanAttackLeft(val))
				{
					attackLeftIsActive = false;
				}
				if (!PossessionAttackRangeGate.CanAttackRight(val))
				{
					attackRightIsActive = false;
				}
			}
		}

		private void UpdateDotTint(CameraAbilityPossess possess)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)possess == (Object)null))
			{
				object? obj = PossessUiField?.GetValue(possess);
				CameraAbilityPossessUI val = (CameraAbilityPossessUI)((obj is CameraAbilityPossessUI) ? obj : null);
				if (val != null)
				{
					GameObject dot = val.Dot;
					if ((Object)(object)dot == (Object)null || !dot.activeInHierarchy)
					{
						_dotImage = null;
						return;
					}
					if ((Object)(object)_dotImage == (Object)null || (Object)(object)((Component)_dotImage).gameObject != (Object)(object)dot)
					{
						_dotImage = dot.GetComponent<Image>() ?? dot.GetComponentInChildren<Image>();
					}
					if (!((Object)(object)_dotImage == (Object)null))
					{
						PossessionAttackRangeGate.RangeGateState lastState = PossessionAttackRangeGate.LastState;
						((Graphic)_dotImage).color = ((lastState.GateActive && !lastState.CanAttack) ? OutOfRangeDotColor : InRangeDotColor);
					}
					return;
				}
			}
			_dotImage = null;
		}

		private void EnsureStyle()
		{
			//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_0026: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (_outOfRangeStyle == null)
			{
				_outOfRangeStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 16
				};
				_outOfRangeStyle.normal.textColor = new Color(1f, 0.3f, 0.3f, 0.95f);
			}
		}

		private static FPSWeapon TryGetFpsWeapon(CameraAbilityPossess possess)
		{
			if ((Object)(object)possess?.currentUnit == (Object)null)
			{
				return null;
			}
			return ((Component)possess.currentUnit).GetComponentInChildren<PlayerHolding>(true)?.weapon;
		}
	}
	internal enum PossessionUnitQueryMode
	{
		RaycastOnly
	}
	internal static class PossessionUnitTargetQuery
	{
		internal readonly struct RayAimSnapshot
		{
			public readonly bool HasAimPoint;

			public readonly Vector3 AimPoint;

			public readonly Unit PrimaryUnit;

			public readonly PossessionCrosshairAim.AimTarget AimTarget;

			public RayAimSnapshot(bool hasAimPoint, Vector3 aimPoint, Unit primaryUnit, PossessionCrosshairAim.AimTarget aimTarget)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				HasAimPoint = hasAimPoint;
				AimPoint = aimPoint;
				PrimaryUnit = primaryUnit;
				AimTarget = aimTarget;
			}
		}

		private static readonly List<Unit> RayUnits = new List<Unit>(24);

		private static readonly HashSet<Unit> RayUnitSet = new HashSet<Unit>();

		private static readonly RaycastHit[] HitBuffer = (RaycastHit[])(object)new RaycastHit[128];

		private static readonly RaycastHit[] LineHitScratch = (RaycastHit[])(object)new RaycastHit[128];

		private static Unit[] _unitsOnRay = Array.Empty<Unit>();

		private static RayAimSnapshot _aimSnapshot;

		private static float _refreshTime = -999f;

		private static int _lastRefreshFrame = -1;

		private static Vector3 _lastCamPos;

		private static Vector3 _lastCamFwd;

		private static float _lastQueryMaxDistance;

		private static int _tabsGameplayLayerMask = -1;

		private static readonly FieldInfo MainRigLayerField = AccessTools.Field(typeof(CameraAbilityPossess), "m_MainRigLayer");

		internal static int GetRaycastLayerMask(CameraAbilityPossess possess)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (_tabsGameplayLayerMask < 0)
			{
				int mask = -1;
				ExcludeLayer(ref mask, "Ignore Raycast");
				ExcludeLayer(ref mask, "Player");
				ExcludeLayer(ref mask, "Water");
				_tabsGameplayLayerMask = mask;
			}
			int num = _tabsGameplayLayerMask;
			if ((Object)(object)possess != (Object)null && MainRigLayerField != null && MainRigLayerField.GetValue(possess) is LayerMask val)
			{
				num |= ((LayerMask)(ref val)).value;
			}
			return num;
		}

		private static void ExcludeLayer(ref int mask, string layerName)
		{
			int num = LayerMask.NameToLayer(layerName);
			if (num >= 0)
			{
				mask &= ~(1 << num);
			}
		}

		internal static void ClearCache()
		{
			_unitsOnRay = Array.Empty<Unit>();
			_aimSnapshot = default(RayAimSnapshot);
			_refreshTime = -999f;
			_lastRefreshFrame = -1;
			RayUnits.Clear();
			RayUnitSet.Clear();
		}

		internal static Unit[] GetUnitsOnCrosshairRay(CameraAbilityPossess possess, Camera camera, float maxDistance)
		{
			if ((Object)(object)possess == (Object)null || (Object)(object)camera == (Object)null || (Object)(object)possess.currentUnit == (Object)null)
			{
				return Array.Empty<Unit>();
			}
			RefreshIfNeeded(possess, camera, maxDistance);
			return _unitsOnRay;
		}

		internal static Unit[] GetUnitsNearCrosshair(CameraAbilityPossess possess, Camera camera)
		{
			return GetUnitsOnCrosshairRay(possess, camera, GetMaxQueryDistance(possess));
		}

		internal static bool TryGetCachedAimSnapshot(CameraAbilityPossess possess, Camera camera, float maxDistance, out RayAimSnapshot snapshot)
		{
			snapshot = default(RayAimSnapshot);
			if ((Object)(object)possess == (Object)null || (Object)(object)camera == (Object)null)
			{
				return false;
			}
			RefreshIfNeeded(possess, camera, maxDistance);
			snapshot = _aimSnapshot;
			return snapshot.HasAimPoint;
		}

		internal static bool TryGetPrimaryRayTarget(CameraAbilityPossess possess, Camera camera, float maxAngleDegrees, out Unit unit, out float distanceToTarget)
		{
			//IL_0040: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			unit = null;
			distanceToTarget = 0f;
			if ((Object)(object)possess == (Object)null || (Object)(object)camera == (Object)null)
			{
				return false;
			}
			float maxQueryDistance = GetMaxQueryDistance(possess);
			RefreshIfNeeded(possess, camera, maxQueryDistance);
			if (_unitsOnRay.Length == 0)
			{
				return false;
			}
			Ray ray = default(Ray);
			((Ray)(ref ray))..ctor(((Component)camera).transform.position, ((Component)camera).transform.forward);
			if (!TryPickBestPrimaryUnit(possess, ray, maxAngleDegrees, out unit, out var _))
			{
				return false;
			}
			distanceToTarget = Vector3.Distance(((Component)camera).transform.position, unit.data.mainRig.position);
			return true;
		}

		internal static IReadOnlyCollection<Unit> GetActiveRayUnitSet()
		{
			return RayUnitSet;
		}

		private static void RefreshIfNeeded(CameraAbilityPossess possess, Camera camera, float maxDistance)
		{
			//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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)camera).transform.position;
			Vector3 forward = ((Component)camera).transform.forward;
			float unscaledTime = Time.unscaledTime;
			float num = Mathf.Clamp(0.15f, 0.05f, 1f);
			float num2 = Mathf.Max(maxDistance, 4f);
			Vector3 val = position - _lastCamPos;
			bool flag = ((Vector3)(ref val)).sqrMagnitude > 0.04f || Vector3.Angle(_lastCamFwd, forward) > 2f || Mathf.Abs(num2 - _lastQueryMaxDistance) > 0.5f;
			if ((flag || _lastRefreshFrame != Time.frameCount || _unitsOnRay.Length < 0) && (flag || !(unscaledTime - _refreshTime < num) || _lastRefreshFrame < 0))
			{
				_refreshTime = unscaledTime;
				_lastRefreshFrame = Time.frameCount;
				_lastCamPos = position;
				_lastCamFwd = forward;
				_lastQueryMaxDistance = num2;
				BuildRaycastList(possess, camera, num2);
				PossessionCrosshairAim.PruneSmoothingCache(RayUnitSet);
			}
		}

		private static void BuildRaycastList(CameraAbilityPossess possess, Camera camera, float maxDistance)
		{
			//IL_001c: 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_0038: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			RayUnits.Clear();
			RayUnitSet.Clear();
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)camera).transform.position, ((Component)camera).transform.forward);
			int raycastLayerMask = GetRaycastLayerMask(possess);
			int num = Physics.RaycastNonAlloc(val, HitBuffer, maxDistance, raycastLayerMask, (QueryTriggerInteraction)2);
			for (int i = 0; i < num; i++)
			{
				LineHitScratch[i] = HitBuffer[i];
			}
			SortHitsByDistance(LineHitScratch, num);
			float assistCastLength = GetAssistCastLength(LineHitScratch, num, maxDistance);
			float assistCastRadius = GetAssistCastRadius(assistCastLength);
			CollectUnitsFromHits(possess, HitBuffer, num, RayUnits, RayUnitSet);
			if (RayUnits.Count == 0 && assistCastRadius > 0.01f)
			{
				int hitCount = Physics.SphereCastNonAlloc(((Ray)(ref val)).origin, assistCastRadius, ((Ray)(ref val)).direction, HitBuffer, assistCastLength, raycastLayerMask, (QueryTriggerInteraction)2);
				CollectAssistUnits(possess, val, HitBuffer, hitCount, assistCastRadius, RayUnits, RayUnitSet);
			}
			int num2 = Mathf.Max(4, 24);
			if (RayUnits.Count > num2)
			{
				RayUnits.RemoveRange(num2, RayUnits.Count - num2);
			}
			_unitsOnRay = ((RayUnits.Count == 0) ? Array.Empty<Unit>() : RayUnits.ToArray());
			_aimSnapshot = BuildAimSnapshot(possess, val, maxDistance, LineHitScratch, num, 35f);
		}

		private static RayAimSnapshot BuildAimSnapshot(CameraAbilityPossess possess, Ray ray, float maxDistance, RaycastHit[] hits, int hitCount, float maxAngleDegrees)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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)
			SortHitsByDistance(hits, hitCount);
			for (int i = 0; i < hitCount; i++)
			{
				Unit componentInParent = ((Component)((RaycastHit)(ref hits[i])).collider).GetComponentInParent<Unit>();
				if (PossessionCrosshairAim.IsValidTargetUnit(possess, componentInParent))
				{
					return new RayAimSnapshot(hasAimPoint: true, ((RaycastHit)(ref hits[i])).point, componentInParent, PossessionCrosshairAim.CreateAimTarget(componentInParent));
				}
			}
			if (TryPickBestPrimaryUnit(possess, ray, maxAngleDegrees, out var unit, out var aimPoint))
			{
				return new RayAimSnapshot(hasAimPoint: true, aimPoint, unit, PossessionCrosshairAim.CreateAimTarget(unit));
			}
			for (int j = 0; j < hitCount; j++)
			{
				if (!PossessionCrosshairAim.IsPossessedUnitCollider(possess, ((RaycastHit)(ref hits[j])).collider))
				{
					return new RayAimSnapshot(hasAimPoint: true, ((RaycastHit)(ref hits[j])).point, null, default(PossessionCrosshairAim.AimTarget));
				}
			}
			return new RayAimSnapshot(hasAimPoint: true, ((Ray)(ref ray)).origin + ((Ray)(ref ray)).direction * maxDistance, null, default(PossessionCrosshairAim.AimTarget));
		}

		private static bool TryPickBestPrimaryUnit(CameraAbilityPossess possess, Ray ray, float maxAngleDegrees, out Unit unit, out Vector3 aimPoint)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_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_00d3: 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)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			unit = null;
			aimPoint = default(Vector3);
			if ((Object)(object)possess?.currentUnit == (Object)null || _unitsOnRay.Length == 0)
			{
				return false;
			}
			float num = float.PositiveInfinity;
			float num2 = float.PositiveInfinity;
			Unit val = null;
			for (int i = 0; i < _unitsOnRay.Length; i++)
			{
				Unit val2 = _unitsOnRay[i];
				if ((Object)(object)val2?.data?.mainRig == (Object)null || !PossessionCrosshairAim.TryGetClosestPointOnUnitToRay(val2, ray, out var closestPoint, out var alongRay) || alongRay < 0.5f)
				{
					continue;
				}
				Vector3 val3 = closestPoint - ((Ray)(ref ray)).origin;
				float num3 = Vector3.Angle(((Ray)(ref ray)).direction, ((Vector3)(ref val3)).normalized);
				float unitSizeSlack = PossessionCrosshairAim.GetUnitSizeSlack(val2);
				if (!(num3 > maxAngleDegrees + 57.29578f * Mathf.Atan(unitSizeSlack / Mathf.Max(alongRay, 1f))))
				{
					float num4 = PerpendicularMiss(ray, closestPoint);
					if (val2.Team == possess.currentUnit.Team)
					{
						num4 = ((!possess.currentUnit.targetYourFriends) ? (num4 * 10f) : (num4 / 10f));
					}
					if (!(num4 > num + 0.001f) && (!(Mathf.Abs(num4 - num) <= 0.001f) || !(alongRay >= num2)))
					{
						num = num4;
						num2 = alongRay;
						val = val2;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			unit = val;
			aimPoint = ((Ray)(ref ray)).origin + ((Ray)(ref ray)).direction * Mathf.Max(0.5f, num2);
			return true;
		}

		private static float GetAssistCastLength(RaycastHit[] lineHits, int lineHitCount, float maxDistance)
		{
			if (lineHitCount > 0)
			{
				return Mathf.Min(maxDistance, ((RaycastHit)(ref lineHits[0])).distance + 0.5f);
			}
			return maxDistance;
		}

		private static float GetAssistCastRadius(float assistLength)
		{
			float num = Mathf.Tan(Mathf.Max(0.01f, 4f) * ((float)Math.PI / 180f)) * Mathf.Max(1f, assistLength);
			return Mathf.Min(Mathf.Max(0.1f, 2f), num);
		}

		private static void CollectAssistUnits(CameraAbilityPossess possess, Ray ray, RaycastHit[] hits, int hitCount, float assistRadius, List<Unit> units, HashSet<Unit> unitSet)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(0.01f, 4f);
			SortHitsByDistance(hits, hitCount);
			for (int i = 0; i < hitCount; i++)
			{
				Unit componentInParent = ((Component)((RaycastHit)(ref hits[i])).collider).GetComponentInParent<Unit>();
				if (!PossessionCrosshairAim.IsValidTargetUnit(possess, componentInParent) || unitSet.Contains(componentInParent) || (Object)(object)componentInParent?.data?.mainRig == (Object)null)
				{
					continue;
				}
				Vector3 point = ((RaycastHit)(ref hits[i])).point;
				Vector3 val = point - ((Ray)(ref ray)).origin;
				float num2 = Vector3.Dot(val, ((Ray)(ref ray)).direction);
				if (!(num2 < 0f))
				{
					float unitSizeSlack = PossessionCrosshairAim.GetUnitSizeSlack(componentInParent);
					if (!(Vector3.Angle(((Ray)(ref ray)).direction, val) > num + 57.29578f * Mathf.Atan(unitSizeSlack / Mathf.Max(num2, 1f))) && !(PerpendicularMiss(ray, point) > assistRadius + unitSizeSlack + 0.01f))
					{
						unitSet.Add(componentInParent);
						units.Add(componentInParent);
					}
				}
			}
		}

		private static float PerpendicularMiss(Ray ray, Vector3 worldPoint)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_002a: 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)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			float num = Vector3.Dot(worldPoint - ((Ray)(ref ray)).origin, ((Ray)(ref ray)).direction);
			if (num < 0f)
			{
				return float.PositiveInfinity;
			}
			Vector3 val = ((Ray)(ref ray)).origin + ((Ray)(ref ray)).direction * num;
			Vector3 val2 = worldPoint - val;
			return ((Vector3)(ref val2)).magnitude;
		}

		private static void CollectUnitsFromHits(CameraAbilityPossess possess, RaycastHit[] hits, int hitCount, List<Unit> units, HashSet<Unit> unitSet)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			SortHitsByDistance(hits, hitCount);
			for (int i = 0; i < hitCount; i++)
			{
				TryAddUnitFromHit(possess, hits[i], units, unitSet);
			}
		}

		private static void SortHitsByDistance(RaycastHit[] hits, int count)
		{
			//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_0043: 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_0018: 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)
			for (int i = 1; i < count; i++)
			{
				RaycastHit val = hits[i];
				int num = i - 1;
				while (num >= 0 && ((RaycastHit)(ref hits[num])).distance > ((RaycastHit)(ref val)).distance)
				{
					hits[num + 1] = hits[num];
					num--;
				}
				hits[num + 1] = val;
			}
		}

		private static void TryAddUnitFromHit(CameraAbilityPossess possess, RaycastHit hit, List<Unit> units, HashSet<Unit> unitSet)
		{
			Unit componentInParent = ((Component)((RaycastHit)(ref hit)).collider).GetComponentInParent<Unit>();
			if (PossessionCrosshairAim.IsValidTargetUnit(possess, componentInParent) && !unitSet.Contains(componentInParent))
			{
				unitSet.Add(componentInParent);
				units.Add(componentInParent);
			}
		}

		private static float GetMaxQueryDistance(CameraAbilityPossess possess)
		{
			return PossessionWeaponRange.GetUnitQueryDistance(possess);
		}
	}
	internal static class PossessionWeaponRange
	{
		internal static float GetMapCrosshairDistance()
		{
			return Mathf.Max(4f, 500f);
		}

		internal static float GetUnitQueryDistance(CameraAbilityPossess possess)
		{
			return GetMapCrosshairDistance();
		}
	}
	internal enum PossessionZoomMode
	{
		Off,
		ScrollWheel
	}
	internal static class PossessionZoom
	{
		private static float _baseFov = 60f;

		private static float _scrollZoomTarget;

		private static float _scrollZoomDisplayed;

		private static Camera _camera;

		private static FieldOfViewLerp _fovLerp;

		private static bool _wasApplyingZoom;

		internal static void OnPossessEnter(Camera camera)
		{
			_camera = camera;
			_fovLerp = (((Object)(object)camera != (Object)null) ? ((Component)camera).GetComponent<FieldOfViewLerp>() : null);
			CaptureVanillaFov();
			ResetZoom();
			_wasApplyingZoom = false;
		}

		internal static void OnCameraModeChanged(Camera camera)
		{
			_camera = camera;
			_fovLerp = (((Object)(object)camera != (Object)null) ? ((Component)camera).GetComponent<FieldOfViewLerp>() : null);
			CaptureVanillaFov();
			RestoreVanillaFov();
			ResetZoom();
			_wasApplyingZoom = false;
		}

		internal static void OnPossessExit()
		{
			RestoreVanillaFov();
			_camera = null;
			_fovLerp = null;
			ResetZoom();
			_wasApplyingZoom = false;
		}

		internal static float GetLookSensitivityScale()
		{
			if (_scrollZoomDisplayed <= 0.001f)
			{
				return 1f;
			}
			float num = 1f + _scrollZoomDisplayed;
			float num2 = 1f / Mathf.Max(1f, num);
			return Mathf.Lerp(1f, num2, 1f);
		}

		internal static void Update(CameraAbilityPossess possess)
		{
			if (!PossessionFreeAimLogic.ShouldRunPossessionFeatures() || PossessionFreeAimLogic.IsSandboxPlacement() || !FirstPersonFreeAimConfig.Enabled || (Object)(object)possess == (Object)null || !possess.IsPossessing)
			{
				return;
			}
			ApplyScrollInput();
			_scrollZoomDisplayed = Mathf.Lerp(_scrollZoomDisplayed, _scrollZoomTarget, Time.unscaledDeltaTime * 12f);
			if (_scrollZoomTarget <= 0.001f && _scrollZoomDisplayed <= 0.001f)
			{
				_scrollZoomDisplayed = 0f;
				if (_wasApplyingZoom)
				{
					RestoreVanillaFov();
					_wasApplyingZoom = false;
				}
				TrackVanillaFov();
			}
			else
			{
				if (!_wasApplyingZoom)
				{
					CaptureVanillaFov();
				}
				_wasApplyingZoom = true;
				ApplyZoomFov(1f + _scrollZoomDisplayed);
			}
		}

		private static void ApplyScrollInput()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			float y = Input.mouseScrollDelta.y;
			if (!(Mathf.Abs(y) < 0.01f))
			{
				_scrollZoomTarget += y * 0.35f;
				_scrollZoomTarget = Mathf.Clamp(_scrollZoomTarget, 0f, 2f);
			}
		}

		private static void ResetZoom()
		{
			_scrollZoomTarget = 0f;
			_scrollZoomDisplayed = 0f;
		}

		private static void CaptureVanillaFov()
		{
			if (!((Object)(object)_camera == (Object)null))
			{
				if ((Object)(object)_fovLerp != (Object)null)
				{
					_baseFov = _fovLerp.targetFOV;
				}
				else
				{
					_baseFov = _camera.fieldOfView;
				}
			}
		}

		private static void TrackVanillaFov()
		{
			if (!((Object)(object)_camera == (Object)null) && !_wasApplyingZoom)
			{
				if ((Object)(object)_fovLerp != (Object)null)
				{
					_baseFov = _fovLerp.targetFOV;
				}
				else
				{
					_baseFov = _camera.fieldOfView;
				}
			}
		}

		private static void ApplyZoomFov(float zoomMultiplier)
		{
			if (!((Object)(object)_camera == (Object)null) && !(zoomMultiplier <= 1.001f))
			{
				float num = _baseFov / zoomMultiplier;
				if ((Object)(object)_fovLerp != (Object)null)
				{
					_fovLerp.targetFOV = num;
				}
				else
				{
					_camera.fieldOfView = num;
				}
			}
		}

		private static void RestoreVanillaFov()
		{
			if (!((Object)(object)_camera == (Object)null))
			{
				if ((Object)(object)_fovLerp != (Object)null)
				{
					_fovLerp.targetFOV = _baseFov;
				}
				else
				{
					_camera.fieldOfView = _baseFov;
				}
			}
		}
	}
}