using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Lamb.UI;
using MMTools;
using Microsoft.CodeAnalysis;
using Spine;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Follower Drag")]
[assembly: AssemblyDescription("Standalone Cult of the Lamb direct follower drag prototype.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("FollowerDrag")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("87a3c5bd-34f9-4f86-b2f4-792c7e1fdc53")]
[assembly: AssemblyFileVersion("0.4.0.0")]
[assembly: AssemblyVersion("0.4.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 FollowerDrag
{
	[BepInPlugin("com.cotl.followerdrag", "Follower Drag", "0.5.4")]
	public sealed class FollowerDragPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.cotl.followerdrag";

		public const string PluginName = "Follower Drag";

		public const string PluginVersion = "0.5.4";

		private FollowerDragController _controller;

		private Harmony _harmony;

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			FollowerDragConfig.Bind(((BaseUnityPlugin)this).Config);
			_harmony = new Harmony("com.cotl.followerdrag");
			_harmony.PatchAll(typeof(FollowerDragPlugin).Assembly);
			_controller = ((Component)this).gameObject.AddComponent<FollowerDragController>();
			FollowerDragController.Instance = _controller;
			Log.LogInfo((object)"Follower Drag 0.5.4 loaded.");
		}

		private void OnDestroy()
		{
			if ((Object)(object)_controller != (Object)null)
			{
				_controller.CancelCurrentDrag();
				FollowerDragController.Instance = null;
				_controller = null;
			}
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			_harmony = null;
		}
	}
	[HarmonyPatch(typeof(Interactor), "Update")]
	internal static class InteractorUpdatePatch
	{
		private static bool Prefix(Interactor __instance)
		{
			FollowerDragController instance = FollowerDragController.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				return !instance.ShouldSuppressVanillaInteraction(__instance);
			}
			return true;
		}
	}
	internal static class FollowerDragConfig
	{
		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<int> MouseButton;

		internal static ConfigEntry<float> HitRadius;

		internal static ConfigEntry<float> GridSnapRange;

		internal static ConfigEntry<float> MarkerSize;

		internal static ConfigEntry<bool> AssignWorkOnDrop;

		internal static ConfigEntry<float> WorkSearchRadius;

		internal static ConfigEntry<bool> SkipProtectedFollowers;

		internal static ConfigEntry<bool> ShowPrompt;

		internal static ConfigEntry<string> CarryAnimation;

		internal static ConfigEntry<float> CarryBobHeight;

		internal static ConfigEntry<float> CarryBobSpeed;

		internal static ConfigEntry<bool> UseGauntletCursor;

		internal static ConfigEntry<int> CursorMaxSize;

		internal static ConfigEntry<bool> DebugLogging;

		internal static void Bind(ConfigFile config)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Expected O, but got Unknown
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			Enabled = config.Bind<bool>("General", "Enabled", true, "Enable direct mouse follower dragging.");
			MouseButton = config.Bind<int>("Input", "MouseButton", 0, new ConfigDescription("Mouse button used to grab and drag. 0 is left, 1 is right, 2 is middle.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 2), Array.Empty<object>()));
			HitRadius = config.Bind<float>("Input", "HitRadius", 0.75f, new ConfigDescription("Fallback follower hit radius when the follower collider is not directly hit.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 1.5f), Array.Empty<object>()));
			GridSnapRange = config.Bind<float>("Placement", "GridSnapRange", 1f, new ConfigDescription("Maximum distance from the cursor to the nearest plot grid tile.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.4f, 2.5f), Array.Empty<object>()));
			MarkerSize = config.Bind<float>("Placement", "MarkerSize", 0.72f, new ConfigDescription("Size of the drag placement marker.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 1.5f), Array.Empty<object>()));
			AssignWorkOnDrop = config.Bind<bool>("Work assignment", "AssignWorkOnDrop", true, "After a successful drop, send the follower to the nearest valid tree, waste pile, farm plot, rubble node, or unfinished build site near the release point.");
			WorkSearchRadius = config.Bind<float>("Work assignment", "WorkSearchRadius", 2.5f, new ConfigDescription("Maximum distance from the release point to look for a work target.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 6f), Array.Empty<object>()));
			SkipProtectedFollowers = config.Bind<bool>("Safety", "SkipProtectedFollowers", true, "Skip followers the game marks as explicitly locked or protected. Ordinary interaction tasks can still be interrupted by a drag.");
			ShowPrompt = config.Bind<bool>("UI", "ShowPrompt", true, "Show the small drag instruction panel while a follower is held.");
			CarryAnimation = config.Bind<string>("Held follower", "CarryAnimation", "Medic/carried-run", "Follower body animation used while the Crown is holding a follower.");
			CarryBobHeight = config.Bind<float>("Held follower", "CarryBobHeight", 0.12f, new ConfigDescription("Additional vertical bob applied to the follower while held.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.4f), Array.Empty<object>()));
			CarryBobSpeed = config.Bind<float>("Held follower", "CarryBobSpeed", 5.5f, new ConfigDescription("Speed of the held follower's floating bob.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 15f), Array.Empty<object>()));
			UseGauntletCursor = config.Bind<bool>("Cursor", "UseGauntletCursor", true, "Show the game's gauntlet artwork when hovering over or holding a follower.");
			CursorMaxSize = config.Bind<int>("Cursor", "CursorMaxSize", 72, new ConfigDescription("Maximum pixel size of the gauntlet cursor artwork.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(24, 128), Array.Empty<object>()));
			DebugLogging = config.Bind<bool>("Debug", "DebugLogging", false, "Write follower drag state changes to the BepInEx log.");
		}
	}
	internal sealed class FollowerDragController : MonoBehaviour
	{
		private enum WorkKind
		{
			None,
			Tree,
			Waste,
			Farm,
			Rubble,
			BuildSite,
			BuildProject
		}

		private sealed class WorkCandidate
		{
			internal WorkKind Kind;

			internal int StructureId;

			internal Vector3 Position;

			internal float Distance;

			internal FollowerTask CreateTask()
			{
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Invalid comparison between Unknown and I4
				switch (Kind)
				{
				case WorkKind.Tree:
				{
					Structures_Tree structureByID2 = StructureManager.GetStructureByID<Structures_Tree>(StructureId);
					if (structureByID2 == null || structureByID2.TreeChopped || ((StructureBrain)structureByID2).Data == null || ((StructureBrain)structureByID2).Data.IsSapling)
					{
						return null;
					}
					return (FollowerTask)(object)new PersistentChopTreesTask(StructureId);
				}
				case WorkKind.Waste:
				{
					Structures_Waste structureByID4 = StructureManager.GetStructureByID<Structures_Waste>(StructureId);
					if (structureByID4 == null || ((StructureBrain)structureByID4).Data == null || structureByID4.ProgressFinished || (int)((StructureBrain)structureByID4).Data.Type == 414)
					{
						return null;
					}
					return (FollowerTask)(object)new PersistentCleanWasteTask(StructureId);
				}
				case WorkKind.Farm:
				{
					Structures_FarmerStation structureByID6 = StructureManager.GetStructureByID<Structures_FarmerStation>(StructureId);
					if (structureByID6 == null || ((StructureBrain)structureByID6).Data == null)
					{
						return null;
					}
					return (FollowerTask)(object)new PersistentFarmTask(StructureId);
				}
				case WorkKind.Rubble:
				{
					Structures_Rubble structureByID3 = StructureManager.GetStructureByID<Structures_Rubble>(StructureId);
					if (structureByID3 == null || structureByID3.ProgressFinished || structureByID3.AvailableSlotCount <= 0)
					{
						return null;
					}
					return (FollowerTask)(object)new PersistentClearRubbleTask(StructureId);
				}
				case WorkKind.BuildSite:
				{
					Structures_BuildSite structureByID5 = StructureManager.GetStructureByID<Structures_BuildSite>(StructureId);
					if (structureByID5 == null || structureByID5.ProgressFinished || structureByID5.IsObstructed)
					{
						return null;
					}
					return (FollowerTask)(object)new PersistentBuildTask(StructureId);
				}
				case WorkKind.BuildProject:
				{
					Structures_BuildSiteProject structureByID = StructureManager.GetStructureByID<Structures_BuildSiteProject>(StructureId);
					if (structureByID == null || structureByID.ProgressFinished)
					{
						return null;
					}
					return (FollowerTask)(object)new PersistentBuildProjectTask(StructureId);
				}
				default:
					return null;
				}
			}
		}

		private sealed class PersistentChopTreesTask : FollowerTask_ChopTrees
		{
			private const float ProgressWatchdogSeconds = 1.5f;

			private const float MinimumHitInterval = 0.12f;

			private readonly int _targetTreeId;

			private bool _sharedClaimed;

			private bool _finishing;

			private bool _progressInitialized;

			private float _lastObservedProgress;

			private float _lastProgressChangeTime;

			private float _lastHitTime = -999f;

			public override bool BlockTaskChanges => true;

			internal PersistentChopTreesTask(int treeId)
				: base(treeId)
			{
				_targetTreeId = treeId;
			}

			public override void ClaimReservations()
			{
				((FollowerTask_ChopTrees)this).ClaimReservations();
				ClaimSharedTree();
			}

			public override void ReleaseReservations()
			{
				((FollowerTask_ChopTrees)this).ReleaseReservations();
				ReleaseSharedTree();
			}

			protected override void OnStart()
			{
				Structures_Tree structureByID = StructureManager.GetStructureByID<Structures_Tree>(_targetTreeId);
				if (structureByID == null || ((StructureBrain)structureByID).Data == null || structureByID.TreeChopped || ((StructureBrain)structureByID).Data.IsSapling)
				{
					FinishAssignedTree();
					return;
				}
				ClaimSharedTree();
				((StructureBrain)structureByID).ReservedForTask = true;
				ObserveTreeProgress(structureByID);
				((FollowerTask)this).ClearDestination();
				((FollowerTask)this).SetState((FollowerTaskState)3);
			}

			public override void OnDoingBegin(Follower follower)
			{
				((FollowerTask_ChopTrees)this).OnDoingBegin(follower);
				ObserveTreeProgress(GetTargetTree());
			}

			protected override void TaskTick(float deltaGameTime)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Invalid comparison between Unknown and I4
				if ((int)((FollowerTask)this).State != 4)
				{
					return;
				}
				Structures_Tree targetTree = GetTargetTree();
				if (targetTree == null || ((StructureBrain)targetTree).Data == null || targetTree.TreeChopped)
				{
					FinishAssignedTree();
					return;
				}
				if (!_progressInitialized)
				{
					ObserveTreeProgress(targetTree);
				}
				else if (!Mathf.Approximately(((StructureBrain)targetTree).Data.Progress, _lastObservedProgress))
				{
					ObserveTreeProgress(targetTree);
				}
				if (Time.unscaledTime - _lastProgressChangeTime >= 1.5f)
				{
					((FollowerTask)this).ProgressTask();
				}
			}

			public override void ProgressTask()
			{
				if (_finishing || Time.unscaledTime - _lastHitTime < 0.12f)
				{
					return;
				}
				Structures_Tree targetTree = GetTargetTree();
				if (targetTree == null || ((StructureBrain)targetTree).Data == null || targetTree.TreeChopped)
				{
					FinishAssignedTree();
					return;
				}
				_lastHitTime = Time.unscaledTime;
				float progress = ((StructureBrain)targetTree).Data.Progress;
				targetTree.TreeHit(0.075f * ((FollowerTask)this).Brain.Info.ProductivityMultiplier, true, ((FollowerTask)this).Brain.Info.ID);
				((FollowerTask)this).Brain.GetXP(0.1f);
				ObserveTreeProgress(targetTree);
				if (Mathf.Approximately(progress, ((StructureBrain)targetTree).Data.Progress))
				{
					_lastProgressChangeTime = Time.unscaledTime;
				}
				if (targetTree.TreeChopped)
				{
					FinishAssignedTree();
				}
			}

			private Structures_Tree GetTargetTree()
			{
				return StructureManager.GetStructureByID<Structures_Tree>(_targetTreeId);
			}

			private void ObserveTreeProgress(Structures_Tree tree)
			{
				if (tree != null && ((StructureBrain)tree).Data != null)
				{
					_progressInitialized = true;
					_lastObservedProgress = ((StructureBrain)tree).Data.Progress;
					_lastProgressChangeTime = Time.unscaledTime;
				}
			}

			private void FinishAssignedTree()
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Invalid comparison between Unknown and I4
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Invalid comparison between Unknown and I4
				if (!_finishing)
				{
					_finishing = true;
					if ((int)((FollowerTask)this).State != 5 && (int)((FollowerTask)this).State != 6)
					{
						((FollowerTask)this).End();
					}
				}
			}

			private void ClaimSharedTree()
			{
				if (!_sharedClaimed)
				{
					SharedTreeClaims.TryGetValue(_targetTreeId, out var value);
					SharedTreeClaims[_targetTreeId] = value + 1;
					_sharedClaimed = true;
				}
			}

			private void ReleaseSharedTree()
			{
				if (!_sharedClaimed)
				{
					return;
				}
				if (SharedTreeClaims.TryGetValue(_targetTreeId, out var value))
				{
					value--;
					if (value <= 0)
					{
						SharedTreeClaims.Remove(_targetTreeId);
					}
					else
					{
						SharedTreeClaims[_targetTreeId] = value;
						Structures_Tree structureByID = StructureManager.GetStructureByID<Structures_Tree>(_targetTreeId);
						if (structureByID != null)
						{
							((StructureBrain)structureByID).ReservedForTask = true;
						}
					}
				}
				_sharedClaimed = false;
			}
		}

		private sealed class PersistentCleanWasteTask : FollowerTask_CleanWaste
		{
			private readonly int _targetWasteId;

			private bool _sharedClaimed;

			public override bool BlockTaskChanges => true;

			internal PersistentCleanWasteTask(int wasteId)
				: base(wasteId)
			{
				_targetWasteId = wasteId;
			}

			public override void ClaimReservations()
			{
				((FollowerTask_CleanWaste)this).ClaimReservations();
				ClaimSharedWaste();
			}

			public override void ReleaseReservations()
			{
				((FollowerTask_CleanWaste)this).ReleaseReservations();
				ReleaseSharedWaste();
			}

			public override void ProgressTask()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Invalid comparison between Unknown and I4
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Invalid comparison between Unknown and I4
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Invalid comparison between Unknown and I4
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Invalid comparison between Unknown and I4
				Structures_Waste structureByID = StructureManager.GetStructureByID<Structures_Waste>(_targetWasteId);
				if (structureByID == null || structureByID.ProgressFinished)
				{
					if ((int)((FollowerTask)this).State != 5 && (int)((FollowerTask)this).State != 6)
					{
						((FollowerTask)this).End();
					}
					return;
				}
				((FollowerTask_CleanWaste)this).ProgressTask();
				structureByID = StructureManager.GetStructureByID<Structures_Waste>(_targetWasteId);
				if ((structureByID == null || structureByID.ProgressFinished) && (int)((FollowerTask)this).State != 5 && (int)((FollowerTask)this).State != 6)
				{
					((FollowerTask)this).End();
				}
			}

			private void ClaimSharedWaste()
			{
				if (!_sharedClaimed)
				{
					SharedWasteClaims.TryGetValue(_targetWasteId, out var value);
					SharedWasteClaims[_targetWasteId] = value + 1;
					_sharedClaimed = true;
				}
			}

			private void ReleaseSharedWaste()
			{
				if (!_sharedClaimed)
				{
					return;
				}
				if (SharedWasteClaims.TryGetValue(_targetWasteId, out var value))
				{
					value--;
					if (value <= 0)
					{
						SharedWasteClaims.Remove(_targetWasteId);
					}
					else
					{
						SharedWasteClaims[_targetWasteId] = value;
						Structures_Waste structureByID = StructureManager.GetStructureByID<Structures_Waste>(_targetWasteId);
						if (structureByID != null)
						{
							((StructureBrain)structureByID).ReservedForTask = true;
						}
					}
				}
				_sharedClaimed = false;
			}
		}

		private sealed class PersistentFarmTask : FollowerTask_Farm
		{
			private readonly int _stationId;

			private bool _sharedClaimed;

			public override bool BlockTaskChanges => true;

			internal PersistentFarmTask(int stationId)
				: base(stationId)
			{
				_stationId = stationId;
			}

			public override void ClaimReservations()
			{
				((FollowerTask_Farm)this).ClaimReservations();
				ClaimSharedStation();
			}

			public override void ReleaseReservations()
			{
				((FollowerTask_Farm)this).ReleaseReservations();
				ReleaseSharedStation();
			}

			private void ClaimSharedStation()
			{
				if (!_sharedClaimed)
				{
					SharedFarmStationClaims.TryGetValue(_stationId, out var value);
					SharedFarmStationClaims[_stationId] = value + 1;
					_sharedClaimed = true;
				}
			}

			private void ReleaseSharedStation()
			{
				if (!_sharedClaimed)
				{
					return;
				}
				if (SharedFarmStationClaims.TryGetValue(_stationId, out var value))
				{
					value--;
					if (value <= 0)
					{
						SharedFarmStationClaims.Remove(_stationId);
					}
					else
					{
						SharedFarmStationClaims[_stationId] = value;
						Structures_FarmerStation structureByID = StructureManager.GetStructureByID<Structures_FarmerStation>(_stationId);
						if (structureByID != null)
						{
							((StructureBrain)structureByID).ReservedForTask = true;
						}
					}
				}
				_sharedClaimed = false;
			}
		}

		private sealed class PersistentClearRubbleTask : FollowerTask_ClearRubble
		{
			public override bool BlockTaskChanges => true;

			internal PersistentClearRubbleTask(int rubbleId)
				: base(rubbleId)
			{
			}
		}

		private sealed class PersistentBuildTask : FollowerTask_Build
		{
			public override bool BlockTaskChanges => true;

			internal PersistentBuildTask(int buildSiteId)
				: base(buildSiteId)
			{
			}
		}

		private sealed class PersistentBuildProjectTask : FollowerTask_BuildProject
		{
			public override bool BlockTaskChanges => true;

			internal PersistentBuildProjectTask(int buildProjectId)
				: base(buildProjectId)
			{
			}
		}

		private enum CursorVisual
		{
			Default,
			Hover,
			Held
		}

		internal static FollowerDragController Instance;

		private Follower _draggedFollower;

		private Vector3 _originalPosition;

		private Vector3 _lastValidPosition;

		private TileGridTile _targetTile;

		private bool _targetIsValid;

		private LineRenderer _targetMarker;

		private Material _markerMaterial;

		private Texture2D _panelTexture;

		private GUIStyle _panelStyle;

		private GUIStyle _labelStyle;

		private Vector3 _grabOffset;

		private Transform _floatingSpineTransform;

		private Vector3 _originalSpineLocalPosition;

		private Quaternion _originalSpineLocalRotation;

		private Vector3 _originalSpineLocalScale;

		private string _heldBodyAnimation;

		private float _heldAnimationStartedAt;

		private float _nextHeldAnimationCheck;

		private bool _heldIconsHidden;

		private CursorVisual _cursorVisual;

		private Texture2D _openCursorTexture;

		private Texture2D _heldCursorTexture;

		private Sprite _openCursorSource;

		private Sprite _heldCursorSource;

		private float _nextCursorAssetAttempt;

		private Vector3 _lastCursorWorld;

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

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

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

		internal void CancelCurrentDrag()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_draggedFollower != (Object)null)
			{
				EndDrag(_draggedFollower, _originalPosition, placed: false, null);
			}
			else
			{
				DestroyVisuals();
			}
			SetCursorVisual(CursorVisual.Default);
		}

		private void Update()
		{
			if ((Object)(object)_draggedFollower != (Object)null)
			{
				if (!CanUseDragInput() || Input.GetKeyDown((KeyCode)27))
				{
					CancelCurrentDrag();
				}
				else if (!Input.GetMouseButton(Mathf.Clamp(FollowerDragConfig.MouseButton.Value, 0, 2)))
				{
					FinishDrag();
				}
				else
				{
					UpdateDragTarget();
				}
			}
			else if (!CanUseDragInput())
			{
				SetCursorVisual(CursorVisual.Default);
			}
			else
			{
				UpdateHoverCursor();
				if (Input.GetMouseButtonDown(Mathf.Clamp(FollowerDragConfig.MouseButton.Value, 0, 2)))
				{
					TryBeginDrag();
				}
			}
		}

		private void LateUpdate()
		{
			if (_cursorVisual != CursorVisual.Default)
			{
				ApplyCursorVisual();
			}
		}

		private void UpdateHoverCursor()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetCursorWorld(out var world))
			{
				SetCursorVisual(CursorVisual.Default);
				return;
			}
			Follower val = FindFollowerUnderCursor(world, useFallback: false);
			SetCursorVisual(((Object)(object)val != (Object)null) ? CursorVisual.Hover : CursorVisual.Default);
		}

		private void BeginFloatingVisual(Follower follower)
		{
			//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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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)
			_floatingSpineTransform = null;
			_originalSpineLocalPosition = Vector3.zero;
			_originalSpineLocalRotation = Quaternion.identity;
			_originalSpineLocalScale = Vector3.one;
			_heldBodyAnimation = null;
			_heldAnimationStartedAt = Time.unscaledTime;
			_nextHeldAnimationCheck = 0f;
			_heldIconsHidden = false;
			if ((Object)(object)follower == (Object)null || (Object)(object)follower.Spine == (Object)null)
			{
				return;
			}
			_floatingSpineTransform = ((Component)follower.Spine).transform;
			_originalSpineLocalPosition = _floatingSpineTransform.localPosition;
			_originalSpineLocalRotation = _floatingSpineTransform.localRotation;
			_originalSpineLocalScale = _floatingSpineTransform.localScale;
			try
			{
				string text = FollowerDragConfig.CarryAnimation.Value;
				if (string.IsNullOrEmpty(text))
				{
					text = "Medic/carried-run";
				}
				follower.State.CURRENT_STATE = (State)49;
				follower.HideAllFollowerIcons();
				_heldIconsHidden = true;
				_heldBodyAnimation = text;
				if (text == "Medic/carried-run")
				{
					SetDirectBodyAnimation(follower, "Medic/carried-start", loop: false);
					AddDirectBodyAnimation(follower, "Medic/carried-run", loop: true, 0f);
				}
				else if (!string.IsNullOrEmpty(text))
				{
					SetDirectBodyAnimation(follower, text, loop: true);
				}
			}
			catch (Exception ex)
			{
				DebugLog("The carry animation could not be applied: " + ex.Message);
				ApplyPossessedFallback(follower);
			}
		}

		private void UpdateFloatingVisual()
		{
			//IL_002a: 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_006d: 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_00a3: 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_00b9: 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)
			if (!((Object)(object)_floatingSpineTransform == (Object)null) && !((Object)(object)_draggedFollower == (Object)null))
			{
				MaintainHeldAnimation(_draggedFollower);
				Vector3 originalSpineLocalPosition = _originalSpineLocalPosition;
				float value = FollowerDragConfig.CarryBobHeight.Value;
				float value2 = FollowerDragConfig.CarryBobSpeed.Value;
				originalSpineLocalPosition.y += value + Mathf.Sin(Time.unscaledTime * value2) * value * 0.35f;
				_floatingSpineTransform.localPosition = originalSpineLocalPosition;
				float num = Mathf.Sin(Time.unscaledTime * value2 * 0.72f) * 9f;
				_floatingSpineTransform.localRotation = _originalSpineLocalRotation * Quaternion.Euler(0f, 0f, num);
				_floatingSpineTransform.localScale = Vector3.Scale(_originalSpineLocalScale, new Vector3(1.03f, 0.94f, 1f));
			}
		}

		private void MaintainHeldAnimation(Follower follower)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			if ((Object)(object)follower == (Object)null || (Object)(object)follower.Spine == (Object)null || follower.Spine.AnimationState == null)
			{
				return;
			}
			try
			{
				if ((int)follower.State.CURRENT_STATE != 49)
				{
					follower.State.CURRENT_STATE = (State)49;
				}
				if (!(Time.unscaledTime < _nextHeldAnimationCheck))
				{
					_nextHeldAnimationCheck = Time.unscaledTime + 0.2f;
					string currentBodyAnimation = GetCurrentBodyAnimation(follower);
					if (_heldBodyAnimation == "Medic/carried-run" && Time.unscaledTime - _heldAnimationStartedAt > 0.65f && currentBodyAnimation != "Medic/carried-run")
					{
						DebugLog("Native carry track was replaced; using the direct possessed animation fallback.");
						ApplyPossessedFallback(follower);
					}
					else if (_heldBodyAnimation != "Medic/carried-run" && !string.IsNullOrEmpty(_heldBodyAnimation) && currentBodyAnimation != _heldBodyAnimation)
					{
						SetDirectBodyAnimation(follower, _heldBodyAnimation, loop: true);
					}
				}
			}
			catch (Exception ex)
			{
				DebugLog("Held animation maintenance failed: " + ex.Message);
				ApplyPossessedFallback(follower);
			}
		}

		private string GetCurrentBodyAnimation(Follower follower)
		{
			TrackEntry current = follower.Spine.AnimationState.GetCurrent(1);
			if (current == null || current.Animation == null)
			{
				return null;
			}
			return current.Animation.Name;
		}

		private void SetDirectBodyAnimation(Follower follower, string animation, bool loop)
		{
			follower.Spine.AnimationState.SetAnimation(1, animation, loop);
		}

		private void AddDirectBodyAnimation(Follower follower, string animation, bool loop, float delay)
		{
			follower.Spine.AnimationState.AddAnimation(1, animation, loop, delay);
		}

		private void ApplyPossessedFallback(Follower follower)
		{
			if (!((Object)(object)follower == (Object)null) && !((Object)(object)follower.Spine == (Object)null) && follower.Spine.AnimationState != null)
			{
				follower.State.CURRENT_STATE = (State)49;
				_heldBodyAnimation = "Sin/sin-floating";
				_nextHeldAnimationCheck = Time.unscaledTime + 0.2f;
				SetDirectBodyAnimation(follower, "Sin/sin-floating", loop: true);
			}
		}

		private void EndFloatingVisual(Follower follower)
		{
			//IL_0015: 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_0037: 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_0080: 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_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_0096: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_floatingSpineTransform != (Object)null)
			{
				_floatingSpineTransform.localPosition = _originalSpineLocalPosition;
				_floatingSpineTransform.localRotation = _originalSpineLocalRotation;
				_floatingSpineTransform.localScale = _originalSpineLocalScale;
			}
			if (_heldIconsHidden && (Object)(object)follower != (Object)null)
			{
				try
				{
					follower.ShowAllFollowerIcons(true);
				}
				catch (Exception ex)
				{
					DebugLog("Follower icons could not be restored: " + ex.Message);
				}
			}
			_floatingSpineTransform = null;
			_originalSpineLocalPosition = Vector3.zero;
			_originalSpineLocalRotation = Quaternion.identity;
			_originalSpineLocalScale = Vector3.one;
			_heldBodyAnimation = null;
			_heldAnimationStartedAt = 0f;
			_nextHeldAnimationCheck = 0f;
			_heldIconsHidden = false;
		}

		private void SetCursorVisual(CursorVisual visual)
		{
			if (visual == CursorVisual.Default || !FollowerDragConfig.UseGauntletCursor.Value)
			{
				if (_cursorVisual != CursorVisual.Default)
				{
					RestoreVanillaCursor();
				}
				_cursorVisual = CursorVisual.Default;
				return;
			}
			EnsureCursorAssets();
			if ((Object)(object)((visual == CursorVisual.Held) ? _heldCursorTexture : _openCursorTexture) == (Object)null)
			{
				_cursorVisual = CursorVisual.Default;
				return;
			}
			_cursorVisual = visual;
			ApplyCursorVisual();
		}

		private void ApplyCursorVisual()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = ((_cursorVisual == CursorVisual.Held) ? _heldCursorTexture : _openCursorTexture);
			if (!((Object)(object)val == (Object)null))
			{
				Vector2 val2 = default(Vector2);
				((Vector2)(ref val2))..ctor((float)((Texture)val).width * 0.18f, (float)((Texture)val).height * 0.18f);
				Cursor.SetCursor(val, val2, (CursorMode)0);
			}
		}

		private void EnsureCursorAssets()
		{
			if (!FollowerDragConfig.UseGauntletCursor.Value || Time.unscaledTime < _nextCursorAssetAttempt)
			{
				return;
			}
			_nextCursorAssetAttempt = Time.unscaledTime + 1f;
			try
			{
				WeaponData weaponData = EquipmentManager.GetWeaponData((EquipmentType)400);
				WeaponData weaponData2 = EquipmentManager.GetWeaponData((EquipmentType)407);
				Sprite val = (((Object)(object)weaponData != (Object)null) ? ((EquipmentData)weaponData).UISprite : null);
				if ((Object)(object)val == (Object)null && (Object)(object)weaponData2 != (Object)null)
				{
					val = ((EquipmentData)weaponData2).UISprite;
				}
				Sprite val2 = (((Object)(object)weaponData != (Object)null) ? ((EquipmentData)weaponData).WorldSprite : null);
				if ((Object)(object)val2 == (Object)null && (Object)(object)weaponData2 != (Object)null)
				{
					val2 = (((Object)(object)((EquipmentData)weaponData2).WorldSprite != (Object)null) ? ((EquipmentData)weaponData2).WorldSprite : ((EquipmentData)weaponData2).UISprite);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val;
				}
				if ((Object)(object)val != (Object)(object)_openCursorSource)
				{
					DestroyCursorTexture(ref _openCursorTexture);
					_openCursorSource = val;
					_openCursorTexture = CreateCursorTexture(val);
				}
				if ((Object)(object)val2 != (Object)(object)_heldCursorSource)
				{
					DestroyCursorTexture(ref _heldCursorTexture);
					_heldCursorSource = val2;
					_heldCursorTexture = CreateCursorTexture(val2);
				}
			}
			catch (Exception ex)
			{
				DebugLog("Gauntlet cursor artwork is not ready: " + ex.Message);
			}
		}

		private Texture2D CreateCursorTexture(Sprite source)
		{
			//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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || (Object)(object)source.texture == (Object)null)
			{
				return null;
			}
			Rect textureRect = source.textureRect;
			int num = Mathf.Clamp(Mathf.RoundToInt(((Rect)(ref textureRect)).x), 0, ((Texture)source.texture).width - 1);
			int num2 = Mathf.Clamp(Mathf.RoundToInt(((Rect)(ref textureRect)).y), 0, ((Texture)source.texture).height - 1);
			int num3 = Mathf.Clamp(Mathf.RoundToInt(((Rect)(ref textureRect)).width), 1, ((Texture)source.texture).width - num);
			int num4 = Mathf.Clamp(Mathf.RoundToInt(((Rect)(ref textureRect)).height), 1, ((Texture)source.texture).height - num2);
			RenderTexture val = new RenderTexture(((Texture)source.texture).width, ((Texture)source.texture).height, 0, (RenderTextureFormat)0);
			((Texture)val).filterMode = (FilterMode)1;
			RenderTexture active = RenderTexture.active;
			Texture2D val2 = null;
			try
			{
				Graphics.Blit((Texture)(object)source.texture, val);
				RenderTexture.active = val;
				val2 = new Texture2D(num3, num4, (TextureFormat)4, false, false);
				val2.ReadPixels(new Rect((float)num, (float)num2, (float)num3, (float)num4), 0, 0, false);
				val2.Apply(false, false);
			}
			finally
			{
				RenderTexture.active = active;
				val.Release();
				Object.Destroy((Object)(object)val);
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			((Texture)val2).filterMode = (FilterMode)1;
			((Texture)val2).wrapMode = (TextureWrapMode)1;
			return ResizeCursorTexture(val2);
		}

		private Texture2D ResizeCursorTexture(Texture2D source)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Clamp(FollowerDragConfig.CursorMaxSize.Value, 24, 128);
			if (((Texture)source).width <= num && ((Texture)source).height <= num)
			{
				return source;
			}
			float num2 = Mathf.Min((float)num / (float)((Texture)source).width, (float)num / (float)((Texture)source).height);
			int num3 = Mathf.Max(1, Mathf.RoundToInt((float)((Texture)source).width * num2));
			int num4 = Mathf.Max(1, Mathf.RoundToInt((float)((Texture)source).height * num2));
			RenderTexture val = new RenderTexture(num3, num4, 0, (RenderTextureFormat)0);
			((Texture)val).filterMode = (FilterMode)1;
			RenderTexture active = RenderTexture.active;
			Texture2D val2 = null;
			try
			{
				Graphics.Blit((Texture)(object)source, val);
				RenderTexture.active = val;
				val2 = new Texture2D(num3, num4, (TextureFormat)4, false, false);
				val2.ReadPixels(new Rect(0f, 0f, (float)num3, (float)num4), 0, 0, false);
				val2.Apply(false, false);
			}
			finally
			{
				RenderTexture.active = active;
				val.Release();
				Object.Destroy((Object)(object)val);
			}
			if ((Object)(object)val2 != (Object)null)
			{
				((Texture)val2).filterMode = (FilterMode)1;
				((Texture)val2).wrapMode = (TextureWrapMode)1;
				Object.Destroy((Object)(object)source);
				return val2;
			}
			return source;
		}

		private void DestroyCursorTexture(ref Texture2D texture)
		{
			if ((Object)(object)texture != (Object)null)
			{
				Object.Destroy((Object)(object)texture);
				texture = null;
			}
		}

		private void DestroyCursorAssets()
		{
			DestroyCursorTexture(ref _openCursorTexture);
			DestroyCursorTexture(ref _heldCursorTexture);
			_openCursorSource = null;
			_heldCursorSource = null;
		}

		private void RestoreVanillaCursor()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				UIManager instance = MonoSingleton<UIManager>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					int currentCursor = instance.currentCursor;
					int currentCursor2 = ((currentCursor == 0) ? 1 : 0);
					instance.SetCurrentCursor(currentCursor2);
					instance.SetCurrentCursor(currentCursor);
					return;
				}
			}
			catch (Exception ex)
			{
				DebugLog("The vanilla cursor could not be refreshed: " + ex.Message);
			}
			Cursor.SetCursor((Texture2D)null, Vector2.zero, (CursorMode)0);
		}

		private bool CanUseDragInput()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			if (!FollowerDragConfig.Enabled.Value || (Object)(object)PlayerFarming.Instance == (Object)null)
			{
				return false;
			}
			if ((int)PlayerFarming.Location != 1 || Time.timeScale <= 0f || SimulationManager.IsPaused)
			{
				return false;
			}
			if (LetterBox.IsPlaying || MMConversation.isPlaying || (Object)(object)PlacementObject.Instance != (Object)null)
			{
				return false;
			}
			return true;
		}

		private void TryBeginDrag()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_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_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_0082: 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)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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)
			if (!TryGetCursorWorld(out var world))
			{
				return;
			}
			Follower val = FindFollowerUnderCursor(world, useFallback: true);
			if ((Object)(object)val == (Object)null || !IsSelectable(val))
			{
				return;
			}
			PlacementRegion instance = PlacementRegion.Instance;
			if ((Object)(object)instance == (Object)null || instance.Grid == null || instance.Grid.Count == 0)
			{
				DebugLog("Follower drag ignored because the base plot grid is unavailable.");
				return;
			}
			_draggedFollower = val;
			_originalPosition = ((Component)val).transform.position;
			_lastValidPosition = _originalPosition;
			_grabOffset = _originalPosition - world;
			_grabOffset.z = 0f;
			_targetTile = null;
			_targetIsValid = false;
			_lastCursorWorld = world;
			try
			{
				ClearPrimaryVanillaInteraction();
				val.PickUp();
				val.ClearPath();
				val.Brain.LastPosition = ((Component)val).transform.position;
				BeginFloatingVisual(val);
				CreateVisuals();
				SetCursorVisual(CursorVisual.Held);
				UpdateDragTarget();
				DebugLog("Grabbed follower " + val.Brain.Info.ID + ".");
			}
			catch (Exception ex)
			{
				FollowerDragPlugin.Log.LogError((object)("Follower drag could not start: " + ex));
				EndDrag(val, _originalPosition, placed: false, null);
			}
		}

		internal bool ShouldSuppressVanillaInteraction(Interactor interactor)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)interactor == (Object)null || (Object)(object)PlayerFarming.Instance == (Object)null || (Object)(object)interactor != (Object)(object)PlayerFarming.Instance.interactor)
			{
				return false;
			}
			if ((Object)(object)_draggedFollower != (Object)null)
			{
				return true;
			}
			if (!CanUseDragInput())
			{
				return false;
			}
			if (!Input.GetMouseButtonDown(Mathf.Clamp(FollowerDragConfig.MouseButton.Value, 0, 2)))
			{
				return false;
			}
			if (!TryGetCursorWorld(out var world))
			{
				return false;
			}
			Follower val = FindFollowerUnderCursor(world, useFallback: true);
			if ((Object)(object)val != (Object)null)
			{
				return IsSelectable(val);
			}
			return false;
		}

		private void ClearPrimaryVanillaInteraction()
		{
			PlayerFarming instance = PlayerFarming.Instance;
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.interactor == (Object)null))
			{
				Interactor interactor = instance.interactor;
				Interaction currentInteraction = interactor.CurrentInteraction;
				Interaction previousInteraction = interactor.PreviousInteraction;
				if ((Object)(object)currentInteraction != (Object)null)
				{
					currentInteraction.OnBecomeNotCurrent(instance);
				}
				if ((Object)(object)previousInteraction != (Object)null && (Object)(object)previousInteraction != (Object)(object)currentInteraction)
				{
					previousInteraction.OnBecomeNotCurrent(instance);
				}
				interactor.CurrentInteraction = null;
				interactor.PreviousInteraction = null;
				interactor.TempInteraction = null;
				if ((Object)(object)interactor.indicator != (Object)null)
				{
					interactor.HideIndicator();
				}
			}
		}

		private Follower FindFollowerUnderCursor(Vector3 cursorWorld, bool useFallback)
		{
			//IL_0010: 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_0052: 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_0068: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			Follower val = null;
			float num = float.MaxValue;
			Follower val2 = null;
			float num2 = float.MaxValue;
			Collider2D[] array = Physics2D.OverlapPointAll(Vector2.op_Implicit(cursorWorld));
			for (int i = 0; i < array.Length; i++)
			{
				if ((Object)(object)array[i] == (Object)null)
				{
					continue;
				}
				Follower componentInParent = ((Component)array[i]).GetComponentInParent<Follower>();
				if (!((Object)(object)componentInParent == (Object)null) && IsInBase(componentInParent))
				{
					if (TryGetFollowerVisualHit(componentInParent, cursorWorld, out var distance) && distance < num)
					{
						val = componentInParent;
						num = distance;
					}
					float num3 = Vector2.Distance(Vector2.op_Implicit(cursorWorld), Vector2.op_Implicit(((Component)componentInParent).transform.position));
					if (num3 < num2)
					{
						val2 = componentInParent;
						num2 = num3;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if (Follower.Followers == null)
			{
				if (!((Object)(object)val2 != (Object)null) || HasFollowerVisual(val2))
				{
					return null;
				}
				return val2;
			}
			for (int j = 0; j < Follower.Followers.Count; j++)
			{
				Follower val3 = Follower.Followers[j];
				if (!((Object)(object)val3 == (Object)null) && IsInBase(val3) && TryGetFollowerVisualHit(val3, cursorWorld, out var distance2) && distance2 < num)
				{
					val = val3;
					num = distance2;
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if ((Object)(object)val2 != (Object)null && !HasFollowerVisual(val2))
			{
				return val2;
			}
			if (!useFallback)
			{
				return null;
			}
			float value = FollowerDragConfig.HitRadius.Value;
			Follower result = null;
			float num4 = float.MaxValue;
			for (int k = 0; k < Follower.Followers.Count; k++)
			{
				Follower val4 = Follower.Followers[k];
				if (!((Object)(object)val4 == (Object)null) && IsInBase(val4) && !HasFollowerVisual(val4))
				{
					float num5 = Vector2.Distance(Vector2.op_Implicit(cursorWorld), Vector2.op_Implicit(((Component)val4).transform.position));
					if (num5 <= value && num5 < num4)
					{
						result = val4;
						num4 = num5;
					}
				}
			}
			return result;
		}

		private bool TryGetFollowerVisualHit(Follower follower, Vector3 cursorWorld, out float distance)
		{
			//IL_0014: 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_002e: 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_0048: 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_0062: 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_007f: 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_0087: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			distance = float.MaxValue;
			if (!TryGetFollowerVisualBounds(follower, out var bounds))
			{
				return false;
			}
			if (cursorWorld.x < ((Bounds)(ref bounds)).min.x - 0.12f || cursorWorld.x > ((Bounds)(ref bounds)).max.x + 0.12f || cursorWorld.y < ((Bounds)(ref bounds)).min.y - 0.12f || cursorWorld.y > ((Bounds)(ref bounds)).max.y + 0.12f)
			{
				return false;
			}
			distance = Vector2.Distance(Vector2.op_Implicit(cursorWorld), new Vector2(((Bounds)(ref bounds)).center.x, ((Bounds)(ref bounds)).center.y));
			return true;
		}

		private bool HasFollowerVisual(Follower follower)
		{
			Bounds bounds;
			return TryGetFollowerVisualBounds(follower, out bounds);
		}

		private bool TryGetFollowerVisualBounds(Follower follower, out Bounds bounds)
		{
			//IL_0001: 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_0059: 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_0061: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			if ((Object)(object)follower == (Object)null || (Object)(object)follower.Spine == (Object)null)
			{
				return false;
			}
			Renderer val = ((Component)follower.Spine).GetComponent<Renderer>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)follower.Spine).GetComponentInChildren<Renderer>(true);
			}
			if (!((Object)(object)val == (Object)null) && val.enabled)
			{
				Bounds bounds2 = val.bounds;
				Vector3 size = ((Bounds)(ref bounds2)).size;
				if (!(((Vector3)(ref size)).sqrMagnitude <= 0.0001f))
				{
					bounds = val.bounds;
					return true;
				}
			}
			return false;
		}

		private bool IsInBase(Follower follower)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			if ((Object)(object)follower != (Object)null && ((Behaviour)follower).isActiveAndEnabled && follower.Brain != null)
			{
				return (int)follower.Brain.Location == 1;
			}
			return false;
		}

		private bool IsSelectable(Follower follower)
		{
			if (!IsInBase(follower) || follower.Brain.Info == null)
			{
				return false;
			}
			if (!FollowerDragConfig.SkipProtectedFollowers.Value)
			{
				return true;
			}
			try
			{
				int iD = follower.Brain.Info.ID;
				bool flag = true;
				bool flag2 = true;
				bool flag3 = true;
				bool flag4 = true;
				bool flag5 = true;
				if (FollowerManager.FollowerLocked(ref iD, ref flag, ref flag2, ref flag3, ref flag4, ref flag5))
				{
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				DebugLog("Follower was skipped because its safety state could not be read: " + ex.Message);
				return false;
			}
		}

		private void UpdateDragTarget()
		{
			//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_0033: 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_00b9: 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_00d9: 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_00e6: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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)
			if ((Object)(object)_draggedFollower == (Object)null)
			{
				return;
			}
			if (!TryGetCursorWorld(out var world))
			{
				_targetTile = null;
				_targetIsValid = false;
				UpdateMarker(((Component)_draggedFollower).transform.position, valid: false);
				return;
			}
			_lastCursorWorld = world;
			PlacementRegion instance = PlacementRegion.Instance;
			TileGridTile val = null;
			if ((Object)(object)instance != (Object)null && instance.Grid != null && instance.Grid.Count > 0)
			{
				val = instance.GetClosestTileGridTileAtWorldPosition(world);
			}
			_targetTile = val;
			_targetIsValid = val != null && Vector3.Distance(val.WorldPosition, world) <= FollowerDragConfig.GridSnapRange.Value && !val.Occupied && !val.Obstructed && !val.ReservedForWaste;
			Vector3 draggedPosition = world + _grabOffset;
			draggedPosition.z = _originalPosition.z;
			SetDraggedPosition(draggedPosition);
			Vector3 center = val?.WorldPosition ?? world;
			center.z = _originalPosition.z;
			UpdateMarker(center, _targetIsValid);
			if (_targetIsValid)
			{
				Vector3 worldPosition = val.WorldPosition;
				worldPosition.z = _originalPosition.z;
				_lastValidPosition = worldPosition;
			}
			UpdateFloatingVisual();
		}

		private void SetDraggedPosition(Vector3 position)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_draggedFollower == (Object)null) && !(Vector3.SqrMagnitude(((Component)_draggedFollower).transform.position - position) < 0.0001f))
			{
				((Component)_draggedFollower).transform.position = position;
				if (_draggedFollower.Brain != null)
				{
					_draggedFollower.Brain.LastPosition = position;
				}
			}
		}

		private void FinishDrag()
		{
			//IL_0027: 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_002c: 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_0046: 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)
			if (!((Object)(object)_draggedFollower == (Object)null))
			{
				Follower draggedFollower = _draggedFollower;
				Vector3 val = (_targetIsValid ? _lastValidPosition : _originalPosition);
				WorkCandidate workCandidate = (FollowerDragConfig.AssignWorkOnDrop.Value ? FindNearestWorkCandidate(_targetIsValid ? val : _lastCursorWorld) : null);
				EndDrag(draggedFollower, val, _targetIsValid || workCandidate != null, workCandidate);
			}
		}

		private void EndDrag(Follower follower, Vector3 finalPosition, bool placed, WorkCandidate workCandidate)
		{
			//IL_0034: 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)
			_draggedFollower = null;
			_targetTile = null;
			_targetIsValid = false;
			if ((Object)(object)follower != (Object)null)
			{
				try
				{
					EndFloatingVisual(follower);
					follower.ClearPath();
					((Component)follower).transform.position = finalPosition;
					if (follower.Brain != null)
					{
						follower.Brain.LastPosition = finalPosition;
					}
					follower.Drop();
					((MonoBehaviour)this).StartCoroutine(RestoreFollowerAfterDrop(follower, follower.Brain, workCandidate));
					DebugLog((placed ? "Placed " : "Cancelled ") + "follower drag for " + follower.Brain.Info.ID + ".");
				}
				catch (Exception ex)
				{
					FollowerDragPlugin.Log.LogError((object)("Follower drag could not finish cleanly: " + ex));
					try
					{
						follower.Brain.CompleteCurrentTask();
						follower.State.CURRENT_STATE = (State)0;
					}
					catch
					{
					}
				}
			}
			DestroyVisuals();
			SetCursorVisual(CursorVisual.Default);
		}

		private IEnumerator RestoreFollowerAfterDrop(Follower follower, FollowerBrain brain, WorkCandidate workCandidate)
		{
			yield return (object)new WaitForSecondsRealtime(0.4f);
			if ((Object)(object)follower != (Object)null)
			{
				try
				{
					follower.ResetStateAnimations();
				}
				catch (Exception ex)
				{
					DebugLog("Follower animation reset failed after drag: " + ex.Message);
				}
			}
			if (brain != null && workCandidate != null && brain.CanWork)
			{
				try
				{
					FollowerTask val = workCandidate.CreateTask();
					if (val != null)
					{
						brain.HardSwapToTask(val);
						DebugLog("Assigned follower " + brain.Info.ID + " to " + workCandidate.Kind.ToString() + " " + workCandidate.StructureId + ".");
						yield break;
					}
				}
				catch (Exception ex2)
				{
					DebugLog("Work assignment failed; returning follower to vanilla task selection: " + ex2.Message);
				}
			}
			if (brain != null && (int)brain.CurrentTaskType == 0)
			{
				brain.CheckChangeTask();
			}
		}

		private WorkCandidate FindNearestWorkCandidate(Vector3 position)
		{
			//IL_0010: 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_00fd: 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_022a: 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_0311: 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_00c7: Invalid comparison between Unknown and I4
			//IL_0067: 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_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_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: 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_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Invalid comparison between Unknown and I4
			float value = FollowerDragConfig.WorkSearchRadius.Value;
			float radiusSquared = value * value;
			WorkCandidate best = null;
			FollowerLocation val = (FollowerLocation)1;
			List<Structures_Tree> allStructuresOfType = StructureManager.GetAllStructuresOfType<Structures_Tree>(ref val);
			if (allStructuresOfType != null)
			{
				for (int i = 0; i < allStructuresOfType.Count; i++)
				{
					Structures_Tree val2 = allStructuresOfType[i];
					if (val2 != null && ((StructureBrain)val2).Data != null && !val2.TreeChopped && !((StructureBrain)val2).Data.IsSapling)
					{
						ConsiderWorkCandidate(ref best, WorkKind.Tree, ((StructureBrain)val2).Data.ID, ((StructureBrain)val2).Data.Position, position, radiusSquared);
					}
				}
			}
			val = (FollowerLocation)1;
			List<Structures_Waste> allStructuresOfType2 = StructureManager.GetAllStructuresOfType<Structures_Waste>(ref val);
			if (allStructuresOfType2 != null)
			{
				for (int j = 0; j < allStructuresOfType2.Count; j++)
				{
					Structures_Waste val3 = allStructuresOfType2[j];
					if (val3 != null && ((StructureBrain)val3).Data != null && !val3.ProgressFinished && (int)((StructureBrain)val3).Data.Type != 414)
					{
						ConsiderWorkCandidate(ref best, WorkKind.Waste, ((StructureBrain)val3).Data.ID, ((StructureBrain)val3).Data.Position, position, radiusSquared);
					}
				}
			}
			val = (FollowerLocation)1;
			List<Structures_FarmerPlot> allStructuresOfType3 = StructureManager.GetAllStructuresOfType<Structures_FarmerPlot>(ref val);
			val = (FollowerLocation)1;
			List<Structures_FarmerStation> allStructuresOfType4 = StructureManager.GetAllStructuresOfType<Structures_FarmerStation>(ref val);
			if (allStructuresOfType3 != null && allStructuresOfType4 != null)
			{
				for (int k = 0; k < allStructuresOfType3.Count; k++)
				{
					Structures_FarmerPlot val4 = allStructuresOfType3[k];
					if (val4 == null || ((StructureBrain)val4).Data == null || !HasActionableFarmWork(val4))
					{
						continue;
					}
					bool flag = val4.CanPlantSeed() || val4.CanWater() || val4.CanFertilize();
					Structures_FarmerStation val5 = null;
					float num = 6.25f;
					for (int l = 0; l < allStructuresOfType4.Count; l++)
					{
						Structures_FarmerStation val6 = allStructuresOfType4[l];
						if (val6 != null && ((StructureBrain)val6).Data != null)
						{
							float num2 = Vector3.Distance(((StructureBrain)val6).Data.Position, ((StructureBrain)val4).Data.Position);
							if (num2 <= num)
							{
								val5 = val6;
								num = num2;
							}
						}
					}
					if (val5 != null && (flag || (int)((StructureBrain)val5).Data.Type == 266))
					{
						ConsiderWorkCandidate(ref best, WorkKind.Farm, ((StructureBrain)val5).Data.ID, ((StructureBrain)val4).Data.Position, position, radiusSquared);
					}
				}
			}
			val = (FollowerLocation)1;
			List<Structures_Rubble> allStructuresOfType5 = StructureManager.GetAllStructuresOfType<Structures_Rubble>(ref val);
			if (allStructuresOfType5 != null)
			{
				for (int m = 0; m < allStructuresOfType5.Count; m++)
				{
					Structures_Rubble val7 = allStructuresOfType5[m];
					if (val7 != null && ((StructureBrain)val7).Data != null && !val7.ProgressFinished && val7.AvailableSlotCount > 0)
					{
						ConsiderWorkCandidate(ref best, WorkKind.Rubble, ((StructureBrain)val7).Data.ID, ((StructureBrain)val7).Data.Position, position, radiusSquared);
					}
				}
			}
			val = (FollowerLocation)1;
			List<Structures_BuildSite> allStructuresOfType6 = StructureManager.GetAllStructuresOfType<Structures_BuildSite>(ref val);
			if (allStructuresOfType6 != null)
			{
				for (int n = 0; n < allStructuresOfType6.Count; n++)
				{
					Structures_BuildSite val8 = allStructuresOfType6[n];
					if (val8 != null && ((StructureBrain)val8).Data != null && !val8.ProgressFinished && !val8.IsObstructed)
					{
						ConsiderWorkCandidate(ref best, WorkKind.BuildSite, ((StructureBrain)val8).Data.ID, ((StructureBrain)val8).Data.Position, position, radiusSquared);
					}
				}
			}
			val = (FollowerLocation)1;
			List<Structures_BuildSiteProject> allStructuresOfType7 = StructureManager.GetAllStructuresOfType<Structures_BuildSiteProject>(ref val);
			if (allStructuresOfType7 != null)
			{
				for (int num3 = 0; num3 < allStructuresOfType7.Count; num3++)
				{
					Structures_BuildSiteProject val9 = allStructuresOfType7[num3];
					if (val9 != null && ((StructureBrain)val9).Data != null && !val9.ProgressFinished)
					{
						ConsiderWorkCandidate(ref best, WorkKind.BuildProject, ((StructureBrain)val9).Data.ID, ((StructureBrain)val9).Data.Position, position, radiusSquared);
					}
				}
			}
			return best;
		}

		private static bool HasActionableFarmWork(Structures_FarmerPlot plot)
		{
			try
			{
				return plot.CanPlantSeed() || plot.CanWater() || plot.CanFertilize() || plot.CanPickCrop();
			}
			catch
			{
				return false;
			}
		}

		private void ConsiderWorkCandidate(ref WorkCandidate best, WorkKind kind, int structureId, Vector3 candidatePosition, Vector3 releasePosition, float radiusSquared)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: 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_0009: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = candidatePosition - releasePosition;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			if (!(sqrMagnitude > radiusSquared) && (best == null || !(sqrMagnitude >= best.Distance * best.Distance)))
			{
				best = new WorkCandidate
				{
					Kind = kind,
					StructureId = structureId,
					Position = candidatePosition,
					Distance = Mathf.Sqrt(sqrMagnitude)
				};
			}
		}

		private bool TryGetCursorWorld(out Vector3 world)
		{
			//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_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_0047: 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_0051: 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_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)
			world = Vector3.zero;
			Camera val = (((Object)(object)CameraManager.instance != (Object)null) ? CameraManager.instance.CameraRef : Camera.main);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Plane val2 = default(Plane);
			((Plane)(ref val2))..ctor(Vector3.forward, Vector3.zero);
			Ray val3 = val.ScreenPointToRay(Input.mousePosition);
			float num = default(float);
			if (!((Plane)(ref val2)).Raycast(val3, ref num))
			{
				return false;
			}
			world = ((Ray)(ref val3)).GetPoint(num);
			world.z = 0f;
			return true;
		}

		private void CreateVisuals()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			DestroyVisuals();
			GameObject val = new GameObject("FollowerDragTarget");
			val.transform.SetParent(((Component)this).transform, false);
			_targetMarker = val.AddComponent<LineRenderer>();
			_targetMarker.useWorldSpace = true;
			_targetMarker.loop = false;
			_targetMarker.positionCount = 5;
			_targetMarker.widthMultiplier = 0.06f;
			_targetMarker.numCapVertices = 2;
			((Renderer)_targetMarker).sortingOrder = 500;
			_markerMaterial = CreateMarkerMaterial();
			if ((Object)(object)_markerMaterial != (Object)null)
			{
				((Renderer)_targetMarker).sharedMaterial = _markerMaterial;
			}
		}

		private Material CreateMarkerMaterial()
		{
			//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_0025: Expected O, but got Unknown
			Shader val = Shader.Find("Sprites/Default");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return new Material(val)
			{
				hideFlags = (HideFlags)61
			};
		}

		private void UpdateMarker(Vector3 center, bool valid)
		{
			//IL_0020: 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_0031: 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_0037: 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)
			//IL_004e: 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_0065: 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_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_007d: 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_0093: 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_00ad: 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_00f3: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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)
			if (!((Object)(object)_targetMarker == (Object)null))
			{
				float num = FollowerDragConfig.MarkerSize.Value * 0.5f;
				Vector3 val = center + new Vector3(0f, num, -0.05f);
				Vector3 val2 = center + new Vector3(num, 0f, -0.05f);
				Vector3 val3 = center + new Vector3(0f, 0f - num, -0.05f);
				Vector3 val4 = center + new Vector3(0f - num, 0f, -0.05f);
				_targetMarker.SetPosition(0, val);
				_targetMarker.SetPosition(1, val2);
				_targetMarker.SetPosition(2, val3);
				_targetMarker.SetPosition(3, val4);
				_targetMarker.SetPosition(4, val);
				Color val5 = (valid ? new Color(0.2f, 1f, 0.35f, 0.95f) : new Color(1f, 0.2f, 0.2f, 0.95f));
				_targetMarker.startColor = val5;
				_targetMarker.endColor = val5;
			}
		}

		private void DestroyVisuals()
		{
			if ((Object)(object)_targetMarker != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_targetMarker).gameObject);
				_targetMarker = null;
			}
			if ((Object)(object)_markerMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_markerMaterial);
				_markerMaterial = null;
			}
		}

		private void OnGUI()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_draggedFollower == (Object)null) && FollowerDragConfig.ShowPrompt.Value)
			{
				EnsureGuiStyles();
				float num = Mathf.Min(520f, (float)Screen.width - 32f);
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((float)Screen.width - num) * 0.5f, (float)Screen.height - 82f, num, 58f);
				string text = ((_draggedFollower.Brain != null && _draggedFollower.Brain.Info != null) ? _draggedFollower.Brain.Info.Name : "Follower");
				string text2 = (_targetIsValid ? "Release to place" : "Move over an open plot tile");
				GUI.Box(val, GUIContent.none, _panelStyle);
				GUI.Label(new Rect(((Rect)(ref val)).x + 12f, ((Rect)(ref val)).y + 7f, ((Rect)(ref val)).width - 24f, ((Rect)(ref val)).height - 14f), "Crown drag: " + text + "\n" + text2 + "  |  Esc: cancel", _labelStyle);
			}
		}

		private void EnsureGuiStyles()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0041: 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_006b: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (_panelStyle == null)
			{
				_panelTexture = new Texture2D(1, 1, (TextureFormat)4, false);
				((Object)_panelTexture).hideFlags = (HideFlags)61;
				_panelTexture.SetPixel(0, 0, new Color(0f, 0f, 0f, 0.82f));
				_panelTexture.Apply();
				_panelStyle = new GUIStyle(GUI.skin.box);
				_panelStyle.normal.background = _panelTexture;
				_panelStyle.border = new RectOffset(8, 8, 8, 8);
				_panelStyle.padding = new RectOffset(8, 8, 6, 6);
				_labelStyle = new GUIStyle(GUI.skin.label);
				_labelStyle.alignment = (TextAnchor)4;
				_labelStyle.fontSize = 16;
				_labelStyle.normal.textColor = Color.white;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
			CancelCurrentDrag();
			DestroyVisuals();
			RestoreVanillaCursor();
			DestroyCursorAssets();
			if ((Object)(object)_panelTexture != (Object)null)
			{
				Object.Destroy((Object)(object)_panelTexture);
				_panelTexture = null;
			}
		}

		private static void DebugLog(string message)
		{
			if (FollowerDragConfig.DebugLogging.Value && FollowerDragPlugin.Log != null)
			{
				FollowerDragPlugin.Log.LogInfo((object)("[FollowerDrag] " + message));
			}
		}
	}
}