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 Lamb.UI.BuildMenu;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Better Build Backout")]
[assembly: AssemblyProduct("Better Build Backout")]
[assembly: ComVisible(false)]
[assembly: Guid("ce3ea138-0f05-4b72-88a5-e0493434a508")]
[assembly: AssemblyFileVersion("0.1.10.0")]
[assembly: AssemblyVersion("0.1.10.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 BetterBuildBackout
{
	[BepInPlugin("com.cotl.betterbuildertools.betterbuildbackout", "Better Build Backout", "0.1.11")]
	public sealed class BetterBuildBackoutPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.cotl.betterbuildertools.betterbuildbackout";

		public const string PluginName = "Better Build Backout";

		public const string PluginVersion = "0.1.11";

		private Harmony _harmony;

		private bool _hasLastChosen;

		private float _lastReopenTime;

		private float _nextAutoCleanupCheck;

		private float _staleSince;

		private bool _sawBuildActivity;

		private bool _reconciledAfterBuild;

		private float _lastBuildActivityAt;

		private bool _preservingCameraForCatalogue;

		private float _suspendAutoCleanupUntil;

		private int _lastCancelFrame = -1;

		private KeyCode _reopenKey;

		private Interaction_PlacementRegion _lastBuilderInteraction;

		private static readonly MethodInfo OpenBuildMenuMethod = AccessTools.Method(typeof(Interaction_PlacementRegion), "OpenBuildMenu", (Type[])null, (Type[])null);

		private static readonly MethodInfo ClearPrefabsMethod = AccessTools.Method(typeof(PlacementRegion), "ClearPrefabs", (Type[])null, (Type[])null);

		private static readonly FieldInfo TilesField = AccessTools.Field(typeof(PlacementRegion), "Tiles");

		private static readonly FieldInfo TilesInitiatedField = AccessTools.Field(typeof(PlacementRegion), "tilesInitiated");

		private static readonly FieldInfo PlacementObjectField = AccessTools.Field(typeof(PlacementRegion), "placementObject");

		private static readonly FieldInfo PlacementUiField = AccessTools.Field(typeof(PlacementRegion), "placementUI");

		private static readonly FieldInfo IsEditingBuildingsField = AccessTools.Field(typeof(PlacementRegion), "isEditingBuildings");

		internal static ManualLogSource Log { get; private set; }

		internal static BetterBuildBackoutPlugin Instance { get; private set; }

		private void Awake()
		{
			//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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			BetterBuildBackoutConfig.Bind(((BaseUnityPlugin)this).Config);
			_reopenKey = ParseKey(BetterBuildBackoutConfig.ReopenKey.Value, (KeyCode)114);
			_harmony = new Harmony("com.cotl.betterbuildertools.betterbuildbackout");
			_harmony.PatchAll(typeof(BetterBuildBackoutPlugin).Assembly);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Better Build Backout 0.1.11 loaded.");
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			_harmony = null;
			Instance = null;
		}

		internal void RememberChoice(TYPES structureType)
		{
			_hasLastChosen = true;
		}

		internal void RememberBuilderInteraction(Interaction_PlacementRegion interaction)
		{
			if ((Object)(object)interaction != (Object)null)
			{
				_lastBuilderInteraction = interaction;
			}
		}

		internal void QueueReopen()
		{
			if (BetterBuildBackoutConfig.Enabled.Value && _hasLastChosen && BetterBuildBackoutConfig.AutoReopenAfterPlacement.Value && !(Time.unscaledTime - _lastReopenTime < 0.25f))
			{
				_lastReopenTime = Time.unscaledTime;
				((MonoBehaviour)this).StartCoroutine(ReopenRoutine());
			}
		}

		private void Update()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (BetterBuildBackoutConfig.Enabled.Value)
			{
				bool num = IsActiveBuildPlacement();
				if (num)
				{
					_sawBuildActivity = true;
					_staleSince = 0f;
				}
				if (num && Input.GetKeyDown(_reopenKey))
				{
					((MonoBehaviour)this).StartCoroutine(ReopenRoutine());
				}
				if (EditModeTogglePressed())
				{
					_suspendAutoCleanupUntil = Time.unscaledTime + 2.5f;
					_staleSince = 0f;
				}
				if (BetterBuildBackoutConfig.AutoCleanup.Value)
				{
					CheckAutoCleanup();
				}
			}
		}

		internal bool TryHandleCancelBackout()
		{
			if (!BetterBuildBackoutConfig.Enabled.Value || !BetterBuildBackoutConfig.CancelReopensBuildMenu.Value || !IsActiveBuildPlacement())
			{
				return false;
			}
			if ((Object)(object)PlacementRegion.Instance != (Object)null && IsEditBuildingsMode(PlacementRegion.Instance))
			{
				return false;
			}
			if (_lastCancelFrame == Time.frameCount)
			{
				return true;
			}
			_lastCancelFrame = Time.frameCount;
			((MonoBehaviour)this).StartCoroutine(ReopenRoutine());
			return true;
		}

		private IEnumerator ReopenRoutine()
		{
			if (!IsActiveBuildPlacement() || Time.unscaledTime - _lastReopenTime < 0.25f)
			{
				yield break;
			}
			_lastReopenTime = Time.unscaledTime;
			if (!CancelActivePlacementIfNeeded(BetterBuildBackoutConfig.PreserveCameraForCatalogue.Value))
			{
				yield break;
			}
			_preservingCameraForCatalogue = BetterBuildBackoutConfig.PreserveCameraForCatalogue.Value;
			yield return (object)new WaitForSecondsRealtime(BetterBuildBackoutConfig.ReopenDelay.Value);
			if ((Object)(object)_lastBuilderInteraction != (Object)null && OpenBuildMenuMethod != null && OpenBuildMenuMethod.Invoke(_lastBuilderInteraction, null) is IEnumerator enumerator)
			{
				((MonoBehaviour)_lastBuilderInteraction).StartCoroutine(enumerator);
				yield break;
			}
			Log.LogWarning((object)"Could not reopen through Interaction_PlacementRegion; falling back to UIManager.");
			if ((Object)(object)MonoSingleton<UIManager>.Instance != (Object)null && (Object)(object)MonoSingleton<UIManager>.Instance.BuildMenuTemplate != (Object)null)
			{
				Time.timeScale = 0f;
				MonoSingleton<UIManager>.Instance.ShowBuildMenu((TYPES)0);
			}
		}

		internal void MarkBuildMenuSelection()
		{
			_preservingCameraForCatalogue = false;
		}

		internal void HandleBuildMenuCancel()
		{
			if (_preservingCameraForCatalogue)
			{
				_preservingCameraForCatalogue = false;
				RestoreWorldState(resetCameraToPlayer: true);
			}
		}

		private static bool CancelActivePlacementIfNeeded(bool preserveCamera)
		{
			//IL_0010: 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_00b3: 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: Invalid comparison between Unknown and I4
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			PlacementRegion instance = PlacementRegion.Instance;
			if ((Object)(object)instance == (Object)null || (int)instance.CurrentMode == 0)
			{
				return true;
			}
			if ((int)instance.CurrentMode == 4 || (int)instance.CurrentMode == 2)
			{
				Log.LogWarning((object)"Backout ignored while moving/upgrading a structure to avoid losing that edit.");
				return false;
			}
			((MonoBehaviour)instance).StopAllCoroutines();
			GameObject val = (((Object)(object)PlacementObject.Instance != (Object)null) ? ((Component)PlacementObject.Instance).gameObject : null);
			try
			{
				DestroyPlacementTiles(instance);
				ClearPrefabsMethod?.Invoke(instance, null);
				DestroyPrivateObject<PlacementObject>(instance, PlacementObjectField);
				DestroyPrivateObject<PlacementObjectUI>(instance, PlacementUiField);
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Placement cleanup failed: " + ex.Message));
			}
			instance.CurrentMode = (Mode)0;
			instance.PlacementPosition = Vector3.zero;
			TilesInitiatedField?.SetValue(instance, false);
			if ((Object)(object)DLCLandController.Instance != (Object)null)
			{
				DLCLandController.Instance.ShowBridge();
			}
			if ((Object)(object)HUD_Manager.Instance != (Object)null)
			{
				HUD_Manager.Instance.Show(1, false);
				HUD_Manager.Instance.ShowEditMode(false);
			}
			if ((Object)(object)WeatherSystemController.Instance != (Object)null)
			{
				WeatherSystemController.Instance.ShowWeather(false, true);
			}
			if ((Object)(object)LightingManager.Instance != (Object)null)
			{
				LightingManager.Instance.inOverride = false;
				LightingManager.Instance.overrideSettings = null;
				LightingManager.Instance.transitionDurationMultiplier = 0.2f;
				LightingManager.Instance.lerpActive = false;
				LightingManager.Instance.UpdateLighting(true, false, false);
				LightingManager.Instance.PrepareLightingSettings(false);
			}
			if ((Object)(object)GameManager.GetInstance() != (Object)null)
			{
				if ((Object)(object)GameManager.GetInstance().CamFollowTarget != (Object)null)
				{
					((Behaviour)GameManager.GetInstance().CamFollowTarget).enabled = !preserveCamera;
				}
				if ((Object)(object)val != (Object)null)
				{
					GameManager.GetInstance().RemoveFromCamera(val);
				}
				if (!preserveCamera)
				{
					GameManager.GetInstance().RemoveAllFromCamera();
					GameManager.GetInstance().AddPlayerToCamera();
					GameManager.GetInstance().CameraResetTargetZoom();
				}
			}
			GameManager.overridePlayerPosition = false;
			Time.timeScale = 1f;
			return true;
		}

		private void CheckAutoCleanup()
		{
			if (Time.unscaledTime < _suspendAutoCleanupUntil)
			{
				_staleSince = 0f;
			}
			else
			{
				if (Time.unscaledTime < _nextAutoCleanupCheck)
				{
					return;
				}
				_nextAutoCleanupCheck = Time.unscaledTime + 0.25f;
				if (IsActiveBuildPlacement())
				{
					_sawBuildActivity = true;
					_reconciledAfterBuild = false;
					_lastBuildActivityAt = Time.unscaledTime;
					_staleSince = 0f;
					return;
				}
				if (_sawBuildActivity && !_reconciledAfterBuild && !AnyMenuOpen() && Time.unscaledTime - _lastBuildActivityAt >= 0.4f)
				{
					int num = RepairOrphanBuildTiles();
					_reconciledAfterBuild = true;
					if (num > 0)
					{
						Log.LogWarning((object)("Cleared " + num + " orphaned build-grid tile(s) after placement ended."));
					}
				}
				if (!_sawBuildActivity || _preservingCameraForCatalogue || AnyMenuOpen() || !HasStaleBuildSymptoms())
				{
					_staleSince = 0f;
				}
				else if (_staleSince <= 0f)
				{
					_staleSince = Time.unscaledTime;
				}
				else if (!(Time.unscaledTime - _staleSince < BetterBuildBackoutConfig.AutoCleanupDelay.Value))
				{
					RecoverStaleBuildState();
					_sawBuildActivity = false;
					_staleSince = 0f;
					Log.LogInfo((object)"Auto-cleaned stale build placement state.");
				}
			}
		}

		private static void RecoverStaleBuildState()
		{
			PlacementRegion[] array = PlacementRegion.PlacementRegions.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				RecoverPlacementRegion(array[i]);
			}
			if ((Object)(object)PlacementObject.Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)PlacementObject.Instance).gameObject);
			}
			RestoreWorldState(resetCameraToPlayer: true);
			RestorePlayers();
		}

		private static void RecoverPlacementRegion(PlacementRegion region)
		{
			//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)
			if (!((Object)(object)region == (Object)null))
			{
				((MonoBehaviour)region).StopAllCoroutines();
				try
				{
					DestroyPlacementTiles(region);
					DestroyPrivateObject<PlacementObject>(region, PlacementObjectField);
					DestroyPrivateObject<PlacementObjectUI>(region, PlacementUiField);
					ClearPrefabsMethod?.Invoke(region, null);
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("Auto cleanup placement-region recovery failed: " + ex.Message));
				}
				region.CurrentMode = (Mode)0;
				region.PlacementPosition = Vector3.zero;
				TilesInitiatedField?.SetValue(region, false);
			}
		}

		private static void RestoreWorldState(bool resetCameraToPlayer)
		{
			GameManager.overridePlayerPosition = false;
			Time.timeScale = 1f;
			if ((Object)(object)DLCLandController.Instance != (Object)null)
			{
				DLCLandController.Instance.ShowBridge();
			}
			if ((Object)(object)HUD_Manager.Instance != (Object)null)
			{
				HUD_Manager.Instance.Show(1, false);
				HUD_Manager.Instance.ShowEditMode(false);
			}
			if ((Object)(object)WeatherSystemController.Instance != (Object)null)
			{
				WeatherSystemController.Instance.ShowWeather(false, true);
			}
			if ((Object)(object)LightingManager.Instance != (Object)null)
			{
				LightingManager.Instance.inOverride = false;
				LightingManager.Instance.overrideSettings = null;
				LightingManager.Instance.transitionDurationMultiplier = 0.2f;
				LightingManager.Instance.lerpActive = false;
				LightingManager.Instance.UpdateLighting(true, false, false);
				LightingManager.Instance.PrepareLightingSettings(false);
			}
			if ((Object)(object)GameManager.GetInstance() != (Object)null)
			{
				if ((Object)(object)GameManager.GetInstance().CamFollowTarget != (Object)null)
				{
					((Behaviour)GameManager.GetInstance().CamFollowTarget).enabled = true;
				}
				if (resetCameraToPlayer)
				{
					GameManager.GetInstance().RemoveAllFromCamera();
					GameManager.GetInstance().AddPlayerToCamera();
					GameManager.GetInstance().CameraResetTargetZoom();
				}
			}
		}

		private static void RestorePlayers()
		{
			foreach (PlayerFarming player in PlayerFarming.players)
			{
				if (!((Object)(object)player == (Object)null))
				{
					((Component)player).gameObject.SetActive(true);
					player.GoToAndStopping = false;
					if ((Object)(object)player.state != (Object)null)
					{
						player.state.CURRENT_STATE = (State)0;
					}
					if ((Object)(object)player.interactor != (Object)null)
					{
						player.interactor.CurrentInteraction = null;
						player.interactor.PreviousInteraction = null;
					}
					if ((Object)(object)player.indicator != (Object)null)
					{
						((TMP_Text)player.indicator.text).text = "";
						((TMP_Text)player.indicator.SecondaryText).text = "";
						((TMP_Text)player.indicator.Thirdtext).text = "";
						((TMP_Text)player.indicator.Fourthtext).text = "";
						player.indicator.Reset();
						player.indicator.HideTopInfo();
					}
				}
			}
		}

		private static int RepairOrphanBuildTiles()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			//IL_00d1: 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)
			if ((int)PlayerFarming.Location != 1 || (Object)(object)PlacementRegion.Instance == (Object)null || PlacementRegion.Instance.Grid == null)
			{
				return 0;
			}
			HashSet<int> hashSet = new HashSet<int>();
			Structure[] array = Structure.Structures.ToArray();
			foreach (Structure val in array)
			{
				if ((Object)(object)val != (Object)null && val.Brain != null && val.Brain.Data != null && (int)val.Brain.Data.Location == 1)
				{
					hashSet.Add(val.Brain.Data.ID);
				}
			}
			int num = 0;
			foreach (TileGridTile item in PlacementRegion.Instance.Grid)
			{
				if (item != null && item.ObjectID >= 0 && !hashSet.Contains(item.ObjectID) && IsBuildSiteTile(item.ObjectOnTile))
				{
					item.Occupied = false;
					item.Obstructed = false;
					item.ReservedForWaste = false;
					item.IsUpgrade = false;
					item.Collapsed = false;
					item.ObjectID = -1;
					item.ObjectOnTile = (TYPES)0;
					num++;
				}
			}
			return num;
		}

		private static bool IsBuildSiteTile(TYPES type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: 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
			if ((int)type != 31)
			{
				return (int)type == 118;
			}
			return true;
		}

		private static void DestroyPlacementTiles(PlacementRegion region)
		{
			if (!(TilesField?.GetValue(region) is List<PlacementTile> list))
			{
				return;
			}
			PlacementTile[] array = list.ToArray();
			foreach (PlacementTile val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			list.Clear();
		}

		private static void DestroyPrivateObject<T>(PlacementRegion region, FieldInfo field) where T : Component
		{
			object? obj = field?.GetValue(region);
			T val = (T)((obj is T) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
				field.SetValue(region, null);
			}
		}

		private static bool IsActiveBuildPlacement()
		{
			//IL_0011: 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_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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			PlacementRegion instance = PlacementRegion.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			if (GameManager.IsDungeon(PlayerFarming.Location))
			{
				return false;
			}
			if (IsEditBuildingsMode(instance))
			{
				return true;
			}
			if ((int)instance.CurrentMode == 0)
			{
				return false;
			}
			Mode currentMode = instance.CurrentMode;
			if ((int)currentMode != 1 && (int)currentMode != 5)
			{
				return (int)currentMode == 3;
			}
			return true;
		}

		private static bool IsEditBuildingsMode(PlacementRegion region)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			if ((Object)(object)region == (Object)null)
			{
				return false;
			}
			if ((int)region.StructureType == 215)
			{
				return true;
			}
			try
			{
				if (IsEditingBuildingsField != null && (bool)IsEditingBuildingsField.GetValue(region))
				{
					return true;
				}
			}
			catch
			{
			}
			return (int)region.CurrentMode == 3;
		}

		private static bool EditModeTogglePressed()
		{
			if (Input.GetKeyDown((KeyCode)99))
			{
				return true;
			}
			try
			{
				return InputManager.UI.GetEditBuildingsButtonDown((PlayerFarming)null);
			}
			catch
			{
				return false;
			}
		}

		private static bool AnyMenuOpen()
		{
			if (UIMenuBase.ActiveMenus != null)
			{
				return UIMenuBase.ActiveMenus.Count > 0;
			}
			return false;
		}

		private static bool HasStaleBuildSymptoms()
		{
			if (GameManager.overridePlayerPosition || Time.timeScale == 0f)
			{
				return true;
			}
			if ((Object)(object)LightingManager.Instance != (Object)null && LightingManager.Instance.inOverride)
			{
				return true;
			}
			if ((Object)(object)PlayerFarming.Instance == (Object)null || (Object)(object)PlayerFarming.Instance.CameraBone == (Object)null || (Object)(object)GameManager.GetInstance() == (Object)null)
			{
				return false;
			}
			return !GameManager.GetInstance().CameraContains(PlayerFarming.Instance.CameraBone);
		}

		private static KeyCode ParseKey(string raw, KeyCode fallback)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return (KeyCode)Enum.Parse(typeof(KeyCode), raw, ignoreCase: true);
			}
			catch
			{
				return fallback;
			}
		}
	}
	[HarmonyPatch(typeof(Interaction_PlacementRegion), "OnInteract")]
	internal static class InteractionPlacementRegionOnInteractPatch
	{
		private static void Prefix(Interaction_PlacementRegion __instance)
		{
			BetterBuildBackoutPlugin.Instance?.RememberBuilderInteraction(__instance);
		}
	}
	internal static class BetterBuildBackoutConfig
	{
		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<bool> AutoReopenAfterPlacement;

		internal static ConfigEntry<string> ReopenKey;

		internal static ConfigEntry<float> ReopenDelay;

		internal static ConfigEntry<bool> CancelReopensBuildMenu;

		internal static ConfigEntry<bool> ShowToolPrompt;

		internal static ConfigEntry<bool> AutoCleanup;

		internal static ConfigEntry<float> AutoCleanupDelay;

		internal static ConfigEntry<bool> PreserveCameraForCatalogue;

		internal static void Bind(ConfigFile config)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			Enabled = config.Bind<bool>("General", "Enabled", true, "Enable Better Build Backout.");
			AutoReopenAfterPlacement = config.Bind<bool>("Build Menu", "ReopenAfterPlacement", false, "Automatically reopen the build catalogue after successfully placing a structure. This is off by default; use ReopenKey for manual return.");
			if (AutoReopenAfterPlacement.Value)
			{
				AutoReopenAfterPlacement.Value = false;
			}
			ReopenKey = config.Bind<string>("Controls", "ReopenKey", "R", "KeyCode used to reopen the build catalogue after placing a structure.");
			ReopenDelay = config.Bind<float>("Build Menu", "ReopenDelay", 0.15f, new ConfigDescription("Delay before reopening the build catalogue.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.02f, 1f), Array.Empty<object>()));
			CancelReopensBuildMenu = config.Bind<bool>("Controls", "CancelReopensBuildMenu", true, "When placing a structure, the first UI cancel/back press returns to the build catalogue instead of leaving build mode.");
			AutoCleanup = config.Bind<bool>("Cleanup", "AutoCleanup", true, "Automatically recover stale build tint/camera/player-lock state after leaving build placement.");
			AutoCleanupDelay = config.Bind<float>("Cleanup", "AutoCleanupDelay", 0.75f, new ConfigDescription("Seconds stale build symptoms must persist before auto cleanup runs.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 5f), Array.Empty<object>()));
			PreserveCameraForCatalogue = config.Bind<bool>("Build Menu", "PreserveCameraForCatalogue", true, "Keep the current build camera position when returning to the catalogue for a quick structure swap.");
			ShowToolPrompt = config.Bind<bool>("UI", "ShowToolPrompt", false, "Deprecated. Better Build Backout no longer appends text to the vanilla placement indicator.");
		}
	}
	[HarmonyPatch(typeof(RewiredUIInputSource), "GetCancelButtonDown")]
	internal static class RewiredUICancelButtonDownPatch
	{
		private static void Postfix(ref bool __result)
		{
			if (__result && (Object)(object)BetterBuildBackoutPlugin.Instance != (Object)null && BetterBuildBackoutPlugin.Instance.TryHandleCancelBackout())
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(UIBuildMenuController), "ChosenBuilding")]
	internal static class BuildMenuChosenBuildingPatch
	{
		private static void Prefix(TYPES structure)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			BetterBuildBackoutPlugin.Instance?.RememberChoice(structure);
			BetterBuildBackoutPlugin.Instance?.MarkBuildMenuSelection();
		}
	}
	[HarmonyPatch(typeof(UIBuildMenuController), "OnCancelButtonInput")]
	internal static class BuildMenuCancelButtonInputPatch
	{
		private static void Prefix()
		{
			BetterBuildBackoutPlugin.Instance?.HandleBuildMenuCancel();
		}
	}
	[HarmonyPatch(typeof(PlacementRegion), "Play", new Type[] { typeof(Vector3) })]
	internal static class PlacementRegionPlayVectorPatch
	{
		private static void Prefix()
		{
			BetterBuildBackoutPlugin.Instance?.MarkBuildMenuSelection();
		}
	}
	[HarmonyPatch(typeof(PlacementRegion), "Play", new Type[] { typeof(int) })]
	internal static class PlacementRegionPlayIntPatch
	{
		private static void Prefix()
		{
			BetterBuildBackoutPlugin.Instance?.MarkBuildMenuSelection();
		}
	}
	[HarmonyPatch(typeof(PlacementRegion), "Build")]
	internal static class PlacementRegionBuildPatch
	{
		private static void Postfix()
		{
			BetterBuildBackoutPlugin.Instance?.QueueReopen();
		}
	}
}

using System;
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 Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Build Camera Focus")]
[assembly: AssemblyProduct("Build Camera Focus")]
[assembly: ComVisible(false)]
[assembly: Guid("8a83b49b-7176-4d1e-8515-dca4b8737746")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyVersion("0.1.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 BuildCameraFocus
{
	[BepInPlugin("com.cotl.betterbuildertools.buildcamerafocus", "Build Camera Focus", "0.1.0")]
	public sealed class BuildCameraFocusPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.cotl.betterbuildertools.buildcamerafocus";

		public const string PluginName = "Build Camera Focus";

		public const string PluginVersion = "0.1.0";

		private Harmony _harmony;

		internal static ManualLogSource Log { get; private set; }

		internal static BuildCameraFocusPlugin Instance { get; private set; }

		private void Awake()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			BuildCameraFocusConfig.Bind(((BaseUnityPlugin)this).Config);
			_harmony = new Harmony("com.cotl.betterbuildertools.buildcamerafocus");
			_harmony.PatchAll(typeof(BuildCameraFocusPlugin).Assembly);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Build Camera Focus 0.1.0 loaded.");
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			_harmony = null;
			Instance = null;
		}

		internal void Focus(CameraFollowTarget followTarget)
		{
			//IL_002d: 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_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_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_0082: 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_00b2: 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_00db: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			if (BuildCameraFocusConfig.Enabled.Value && !((Object)(object)followTarget == (Object)null) && !((Object)(object)PlacementObject.Instance == (Object)null))
			{
				Vector3 val = ((Component)PlacementObject.Instance).transform.position + Vector3.back * 0.5f;
				float value = BuildCameraFocusConfig.CameraDistance.Value;
				float num = BuildCameraFocusConfig.CameraAngle.Value * ((float)Math.PI / 180f);
				Vector3 val2 = val + new Vector3(0f, value * Mathf.Sin(num), (0f - value) * Mathf.Cos(num));
				float num2 = 1f - Mathf.Exp((0f - BuildCameraFocusConfig.FollowSharpness.Value) * Time.unscaledDeltaTime);
				Vector3 val3 = Vector3.Lerp(((Component)followTarget).transform.position, val2, num2);
				((Component)followTarget).transform.position = val3;
				((Component)followTarget).transform.rotation = Quaternion.Euler(BuildCameraFocusConfig.CameraAngle.Value, 0f, 0f);
				followTarget.CurrentPosition = val3;
				followTarget.CurrentTargetCameraPosition = val3;
			}
		}
	}
	internal static class BuildCameraFocusConfig
	{
		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<float> CameraDistance;

		internal static ConfigEntry<float> CameraAngle;

		internal static ConfigEntry<float> FollowSharpness;

		internal static void Bind(ConfigFile config)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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
			Enabled = config.Bind<bool>("General", "Enabled", true, "Enable Build Camera Focus.");
			CameraDistance = config.Bind<float>("Camera", "CameraDistance", 11f, new ConfigDescription("Camera distance while following the placement object.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(4f, 30f), Array.Empty<object>()));
			CameraAngle = config.Bind<float>("Camera", "CameraAngle", -45f, new ConfigDescription("Camera pitch while following the placement object.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-80f, -15f), Array.Empty<object>()));
			FollowSharpness = config.Bind<float>("Camera", "FollowSharpness", 16f, new ConfigDescription("How quickly the camera follows placement.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 80f), Array.Empty<object>()));
		}
	}
	[HarmonyPatch(typeof(CameraFollowTarget), "LateUpdate")]
	internal static class CameraFollowTargetLateUpdatePatch
	{
		private static void Postfix(CameraFollowTarget __instance)
		{
			BuildCameraFocusPlugin.Instance?.Focus(__instance);
		}
	}
}

using System;
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 Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using src.UINavigator;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Clear This Type")]
[assembly: AssemblyProduct("Clear This Type")]
[assembly: ComVisible(false)]
[assembly: Guid("042701eb-e714-4929-96aa-a7f4e71e6630")]
[assembly: AssemblyFileVersion("0.1.7.0")]
[assembly: AssemblyVersion("0.1.7.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 ClearThisType
{
	[BepInPlugin("com.cotl.betterbuildertools.clearthistype", "Clear This Type", "0.1.9")]
	public sealed class ClearThisTypePlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.cotl.betterbuildertools.clearthistype";

		public const string PluginName = "Clear This Type";

		public const string PluginVersion = "0.1.9";

		private Harmony _harmony;

		private KeyCode _clearKey;

		private KeyCode _controllerConfirmKey;

		private KeyCode _controllerCancelKey;

		private string _statusText = "";

		private float _statusUntil;

		private TYPES _pendingType;

		private float _pendingUntil;

		private string _pendingName = "";

		private int _pendingCount;

		private GUIStyle _boxStyle;

		private GUIStyle _titleStyle;

		private GUIStyle _bodyStyle;

		private GUIStyle _confirmStyle;

		private GUIStyle _cancelStyle;

		private Texture2D _boxBackground;

		private Texture2D _confirmBackground;

		private Texture2D _cancelBackground;

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//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_0040: 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_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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			ClearThisTypeConfig.Bind(((BaseUnityPlugin)this).Config);
			_clearKey = ParseKey(ClearThisTypeConfig.ClearKey.Value, (KeyCode)289);
			_controllerConfirmKey = ParseKey(ClearThisTypeConfig.ControllerConfirmKey.Value, (KeyCode)330);
			_controllerCancelKey = ParseKey(ClearThisTypeConfig.ControllerCancelKey.Value, (KeyCode)331);
			_harmony = new Harmony("com.cotl.betterbuildertools.clearthistype");
			_harmony.PatchAll(typeof(ClearThisTypePlugin).Assembly);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Clear This Type 0.1.9 loaded.");
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			_harmony = null;
			DestroyTexture(ref _boxBackground);
			DestroyTexture(ref _confirmBackground);
			DestroyTexture(ref _cancelBackground);
		}

		private void Update()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			bool allowNearestFallback;
			if (!ClearThisTypeConfig.Enabled.Value || (Object)(object)PlacementRegion.Instance == (Object)null || !IsActiveBuildPlacement())
			{
				ClearPending();
			}
			else if (HasPendingConfirmation() && (Input.GetKeyDown((KeyCode)27) || Input.GetKeyDown((KeyCode)324)))
			{
				ClearPending();
				ShowStatus("Remove all cancelled");
			}
			else if (HasPendingConfirmation() && ControllerCancelPressed())
			{
				ClearPending();
				ShowStatus("Remove all cancelled");
			}
			else if (HasPendingConfirmation() && ControllerConfirmPressed())
			{
				ClearMatchingType(_pendingType);
			}
			else if (ClearPressed(out allowNearestFallback))
			{
				QueueOrClearHoveredType(allowNearestFallback);
			}
		}

		private bool ClearPressed(out bool allowNearestFallback)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			allowNearestFallback = false;
			if (Input.GetKeyDown(_clearKey))
			{
				allowNearestFallback = true;
				return true;
			}
			if (!ClearThisTypeConfig.EnableVanillaClearButton.Value)
			{
				return false;
			}
			try
			{
				return InputManager.Gameplay.GetInteract3ButtonDown(MonoSingleton<UINavigatorNew>.Instance.AllowInputOnlyFromPlayer);
			}
			catch
			{
				return false;
			}
		}

		private bool ControllerConfirmPressed()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown(_controllerConfirmKey))
			{
				return true;
			}
			try
			{
				return InputManager.UI.GetAcceptButtonDown((PlayerFarming)null);
			}
			catch
			{
				return false;
			}
		}

		private bool ControllerCancelPressed()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown(_controllerCancelKey))
			{
				return true;
			}
			try
			{
				return InputManager.UI.GetCancelButtonDown((PlayerFarming)null);
			}
			catch
			{
				return false;
			}
		}

		private unsafe void QueueOrClearHoveredType(bool allowNearestFallback)
		{
			//IL_001b: 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_0081: 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_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_00de: Unknown result type (might be due to invalid IL or missing references)
			Structure val = PlacementRegion.Instance.GetHoveredStructure();
			if ((Object)(object)val == (Object)null && allowNearestFallback)
			{
				val = GetNearestStructureAtPlacement(PlacementRegion.Instance.PlacementPosition, ClearThisTypeConfig.TargetRadius.Value);
			}
			StructureBrain val2 = (((Object)(object)val != (Object)null) ? val.Brain : null);
			if (val2 == null || val2.Data == null)
			{
				Log.LogInfo((object)"Clear This Type: no hovered structure found.");
				ShowStatus("No matching structure under cursor");
				return;
			}
			TYPES type = val2.Data.Type;
			if (!ClearThisTypeConfig.AllowCriticalStructures.Value && IsCritical(type))
			{
				Log.LogWarning((object)("Blocked Clear This Type for protected structure type " + ((object)(*(TYPES*)(&type))/*cast due to .constrained prefix*/).ToString() + "."));
				ShowStatus("Protected structure type");
			}
			else if (ClearThisTypeConfig.RequireConfirmation.Value && (_pendingType != type || Time.unscaledTime > _pendingUntil))
			{
				SetPendingConfirmation(type);
			}
			else
			{
				ClearMatchingType(type);
			}
		}

		private void SetPendingConfirmation(TYPES type)
		{
			//IL_0001: 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_001e: 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)
			_pendingType = type;
			_pendingUntil = Time.unscaledTime + ClearThisTypeConfig.ConfirmationSeconds.Value;
			_pendingName = StructuresData.LocalizedName(type);
			_pendingCount = GetStructuresOfType(type).Count;
			ShowStatus("Remove all " + _pendingName + "? Press again");
		}

		private unsafe void ClearMatchingType(TYPES type)
		{
			//IL_0000: 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_005e: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			List<Structure> structuresOfType = GetStructuresOfType(type);
			int value = ClearThisTypeConfig.MaxClearCount.Value;
			int num = 0;
			int num2 = 0;
			int num3 = structuresOfType.Count - 1;
			while (num3 >= 0 && num < value)
			{
				Structure val = structuresOfType[num3];
				if ((Object)(object)val != (Object)null && val.Brain != null && val.Brain.Data != null)
				{
					TYPES toBuildType = val.Brain.Data.ToBuildType;
					if (RemoveStructureCleanly(val))
					{
						num++;
						num2 += RefundBuildSiteMaterials(type, toBuildType);
					}
				}
				num3--;
			}
			Log.LogInfo((object)("Cleared " + num + " structure(s) of type " + ((object)(*(TYPES*)(&type))/*cast due to .constrained prefix*/).ToString() + "."));
			ShowStatus((num2 > 0) ? ("Cleared " + num + "x " + ((object)(*(TYPES*)(&type))/*cast due to .constrained prefix*/).ToString() + " and refunded " + num2 + " item(s)") : ("Cleared " + num + "x " + ((object)(*(TYPES*)(&type))/*cast due to .constrained prefix*/).ToString()));
			ClearPending();
		}

		private static int RefundBuildSiteMaterials(TYPES type, TYPES toBuildType)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0018: 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_0014: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!ClearThisTypeConfig.RefundBuildSiteMaterials.Value || ((int)type != 31 && (int)type != 118))
			{
				return 0;
			}
			List<ItemCost> cost = StructuresData.GetCost(((int)toBuildType != 0) ? toBuildType : type);
			if (cost == null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < cost.Count; i++)
			{
				ItemCost val = cost[i];
				if (val.CostValue > 0)
				{
					Inventory.AddItem(val.CostItem, val.CostValue, true);
					num += val.CostValue;
				}
			}
			return num;
		}

		private void LateUpdate()
		{
			UpdateVanillaPrompt();
		}

		private void OnGUI()
		{
			//IL_0078: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			if (ClearThisTypeConfig.ShowConfirmationOverlay.Value && ClearThisTypeConfig.Enabled.Value && HasPendingConfirmation() && IsActiveBuildPlacement())
			{
				EnsureStyles();
				float num = Mathf.Min(540f, (float)Screen.width - 48f);
				float num2 = 168f;
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((float)Screen.width - num) * 0.5f, Mathf.Max(56f, (float)Screen.height * 0.18f), num, num2);
				GUI.Box(val, GUIContent.none, _boxStyle);
				GUI.Label(new Rect(((Rect)(ref val)).x + 24f, ((Rect)(ref val)).y + 18f, ((Rect)(ref val)).width - 48f, 34f), "Remove all " + _pendingName + "?", _titleStyle);
				string text = "This will remove " + _pendingCount + " matching structure" + ((_pendingCount == 1) ? "" : "s") + " from the cult. Press " + ClearThisTypeConfig.ClearKey.Value + " again or use Confirm. Controller: Accept to confirm, Back to cancel.";
				GUI.Label(new Rect(((Rect)(ref val)).x + 24f, ((Rect)(ref val)).y + 58f, ((Rect)(ref val)).width - 48f, 44f), text, _bodyStyle);
				Rect val2 = new Rect(((Rect)(ref val)).x + ((Rect)(ref val)).width - 248f, ((Rect)(ref val)).y + ((Rect)(ref val)).height - 48f, 104f, 30f);
				Rect val3 = default(Rect);
				((Rect)(ref val3))..ctor(((Rect)(ref val)).x + ((Rect)(ref val)).width - 132f, ((Rect)(ref val)).y + ((Rect)(ref val)).height - 48f, 84f, 30f);
				if (GUI.Button(val2, "Confirm", _confirmStyle))
				{
					ClearMatchingType(_pendingType);
				}
				if (GUI.Button(val3, "Cancel", _cancelStyle))
				{
					ClearPending();
					ShowStatus("Remove all cancelled");
				}
			}
		}

		private void UpdateVanillaPrompt()
		{
			//IL_0072: 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)
			if (!ClearThisTypeConfig.ShowPrompt.Value || !ClearThisTypeConfig.Enabled.Value || (Object)(object)PlacementRegion.Instance == (Object)null || (Object)(object)PlacementObject.Instance == (Object)null || (Object)(object)PlayerFarming.Instance == (Object)null || (Object)(object)PlayerFarming.Instance.indicator == (Object)null || !IsActiveBuildPlacement())
			{
				return;
			}
			Structure val = PlacementRegion.Instance.GetHoveredStructure();
			if ((Object)(object)val == (Object)null)
			{
				val = GetNearestStructureAtPlacement(PlacementRegion.Instance.PlacementPosition, ClearThisTypeConfig.TargetRadius.Value);
			}
			if (!((Object)(object)val == (Object)null) || !(Time.unscaledTime >= _statusUntil))
			{
				string text = (((int)_pendingType != 0 && Time.unscaledTime <= _pendingUntil) ? "Confirm Remove All" : "Remove All");
				Indicator indicator = PlayerFarming.Instance.indicator;
				indicator.HasThirdInteraction = true;
				indicator.ThirdInteractable = true;
				if (ClearThisTypeConfig.UseVanillaPromptSlot.Value)
				{
					indicator.thirdControlPrompt.Category = 0;
					indicator.thirdControlPrompt.Action = 67;
				}
				string text2 = (((Object)(object)indicator.Thirdtext != (Object)null) ? ((TMP_Text)indicator.Thirdtext).text : string.Empty);
				string text3 = ((Time.unscaledTime < _statusUntil && !string.IsNullOrEmpty(_statusText)) ? _statusText : text);
				((TMP_Text)indicator.Thirdtext).text = (ShouldReplacePrompt(text2) ? text3 : text2);
				indicator.Reset();
			}
		}

		private void ClearVanillaPrompt()
		{
			if ((Object)(object)PlayerFarming.Instance != (Object)null && (Object)(object)PlayerFarming.Instance.indicator != (Object)null && (Object)(object)PlayerFarming.Instance.indicator.Fourthtext != (Object)null)
			{
				((TMP_Text)PlayerFarming.Instance.indicator.Fourthtext).text = "";
				PlayerFarming.Instance.indicator.HasFourthInteraction = false;
			}
		}

		private void ShowStatus(string text)
		{
			_statusText = text;
			_statusUntil = Time.unscaledTime + 2f;
		}

		private bool HasPendingConfirmation()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)_pendingType != 0)
			{
				return Time.unscaledTime <= _pendingUntil;
			}
			return false;
		}

		private void ClearPending()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_pendingType = (TYPES)0;
			_pendingUntil = 0f;
			_pendingName = "";
			_pendingCount = 0;
		}

		private void EnsureStyles()
		{
			//IL_001e: 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_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)
			//IL_0085: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00ae: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_00d4: 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_00fd: Expected O, but got Unknown
			//IL_0108: 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_0115: 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_0123: 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_0138: Expected O, but got Unknown
			//IL_0143: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: 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_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: 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_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			if (_boxStyle == null)
			{
				_boxBackground = MakeTexture(new Color(0.02f, 0.015f, 0.012f, 0.92f));
				_confirmBackground = MakeTexture(new Color(0.66f, 0.08f, 0.06f, 0.94f));
				_cancelBackground = MakeTexture(new Color(0.16f, 0.14f, 0.12f, 0.94f));
				GUIStyle val = new GUIStyle(GUI.skin.box);
				val.normal.background = _boxBackground;
				val.padding = new RectOffset(18, 18, 18, 18);
				_boxStyle = val;
				GUIStyle val2 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 24,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)3
				};
				val2.normal.textColor = new Color(1f, 0.91f, 0.34f, 1f);
				_titleStyle = val2;
				GUIStyle val3 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 16,
					wordWrap = true,
					alignment = (TextAnchor)0
				};
				val3.normal.textColor = Color.white;
				_bodyStyle = val3;
				GUIStyle val4 = new GUIStyle(GUI.skin.button)
				{
					fontSize = 16,
					fontStyle = (FontStyle)1
				};
				val4.normal.background = _confirmBackground;
				val4.normal.textColor = Color.white;
				val4.hover.background = _confirmBackground;
				val4.hover.textColor = Color.white;
				val4.active.background = _confirmBackground;
				val4.active.textColor = Color.white;
				_confirmStyle = val4;
				GUIStyle val5 = new GUIStyle(GUI.skin.button)
				{
					fontSize = 16,
					fontStyle = (FontStyle)1
				};
				val5.normal.background = _cancelBackground;
				val5.normal.textColor = Color.white;
				val5.hover.background = _cancelBackground;
				val5.hover.textColor = Color.white;
				val5.active.background = _cancelBackground;
				val5.active.textColor = Color.white;
				_cancelStyle = val5;
			}
		}

		private static Texture2D MakeTexture(Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, color);
			val.Apply();
			return val;
		}

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

		private static Structure GetNearestStructureAtPlacement(Vector3 position, float radius)
		{
			//IL_0037: 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)
			Structure result = null;
			float num = radius;
			foreach (Structure structure in Structure.Structures)
			{
				if (!((Object)(object)structure == (Object)null) && structure.Brain != null && structure.Brain.Data != null)
				{
					float num2 = Vector3.Distance(position, ((Component)structure).transform.position);
					if (num2 <= num)
					{
						result = structure;
						num = num2;
					}
				}
			}
			return result;
		}

		private static List<Structure> GetStructuresOfType(TYPES type)
		{
			//IL_0042: 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)
			List<Structure> list = new List<Structure>();
			Structure[] array = Structure.Structures.ToArray();
			foreach (Structure val in array)
			{
				if ((Object)(object)val != (Object)null && val.Brain != null && val.Brain.Data != null && val.Brain.Data.Type == type)
				{
					list.Add(val);
				}
			}
			return list;
		}

		private static bool RemoveStructureCleanly(Structure structure)
		{
			if ((Object)(object)structure == (Object)null || structure.Brain == null || structure.Brain.Data == null)
			{
				return false;
			}
			try
			{
				if ((Object)(object)PlacementRegion.Instance != (Object)null)
				{
					PlacementRegion.Instance.DestroyBuilding(structure);
				}
				else
				{
					structure.RemoveStructure();
					Object.Destroy((Object)(object)((Component)structure).gameObject);
				}
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Clean removal failed for " + ((object)Unsafe.As<TYPES, TYPES>(ref structure.Type)/*cast due to .constrained prefix*/).ToString() + ": " + ex.Message));
				return false;
			}
		}

		private unsafe static bool IsCritical(TYPES type)
		{
			string text = ((object)(*(TYPES*)(&type))/*cast due to .constrained prefix*/).ToString();
			if (!text.Contains("TEMPLE") && !text.Contains("SHRINE") && !text.Contains("ALTAR"))
			{
				return text.Contains("BUILDER");
			}
			return true;
		}

		private static bool IsActiveBuildPlacement()
		{
			//IL_001f: 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)
			//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)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0037: 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_003d: Invalid comparison between Unknown and I4
			if ((Object)(object)PlacementObject.Instance == (Object)null || (Object)(object)PlacementRegion.Instance == (Object)null || (int)PlacementRegion.Instance.CurrentMode == 0)
			{
				return false;
			}
			Mode currentMode = PlacementRegion.Instance.CurrentMode;
			if ((int)currentMode != 1 && (int)currentMode != 5)
			{
				return (int)currentMode == 3;
			}
			return true;
		}

		private static bool ShouldReplacePrompt(string existing)
		{
			if (!string.IsNullOrEmpty(existing) && !existing.Contains("Clear this type") && !existing.Contains("Remove All") && !existing.Contains("Remove all ") && !existing.StartsWith("Cleared ") && !(existing == "Protected structure type") && !(existing == "No matching structure under cursor"))
			{
				return existing == "Remove all cancelled";
			}
			return true;
		}

		private static KeyCode ParseKey(string raw, KeyCode fallback)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return (KeyCode)Enum.Parse(typeof(KeyCode), raw, ignoreCase: true);
			}
			catch
			{
				return fallback;
			}
		}
	}
	internal static class ClearThisTypeConfig
	{
		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<string> ClearKey;

		internal static ConfigEntry<string> ControllerConfirmKey;

		internal static ConfigEntry<string> ControllerCancelKey;

		internal static ConfigEntry<int> MaxClearCount;

		internal static ConfigEntry<bool> AllowCriticalStructures;

		internal static ConfigEntry<float> TargetRadius;

		internal static ConfigEntry<bool> ShowPrompt;

		internal static ConfigEntry<bool> EnableVanillaClearButton;

		internal static ConfigEntry<bool> UseVanillaPromptSlot;

		internal static ConfigEntry<bool> ShowConfirmationOverlay;

		internal static ConfigEntry<bool> RequireConfirmation;

		internal static ConfigEntry<float> ConfirmationSeconds;

		internal static ConfigEntry<bool> RefundBuildSiteMaterials;

		internal static void Bind(ConfigFile config)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			Enabled = config.Bind<bool>("General", "Enabled", true, "Enable Clear This Type.");
			ClearKey = config.Bind<string>("Controls", "ClearKey", "F8", "KeyCode used to clear all structures matching the hovered structure type.");
			ControllerConfirmKey = config.Bind<string>("Controls", "ControllerConfirmKey", "JoystickButton0", "Fallback controller KeyCode used to confirm the custom Remove All prompt. JoystickButton0 is normally A/Cross.");
			ControllerCancelKey = config.Bind<string>("Controls", "ControllerCancelKey", "JoystickButton1", "Fallback controller KeyCode used to cancel the custom Remove All prompt. JoystickButton1 is normally B/Circle.");
			EnableVanillaClearButton = config.Bind<bool>("Controls", "EnableVanillaClearButton", true, "Also trigger Clear This Type from the vanilla third interaction button while actively placing/editing.");
			MaxClearCount = config.Bind<int>("Safety", "MaxClearCount", 250, new ConfigDescription("Maximum structures removed by one clear action.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000), Array.Empty<object>()));
			AllowCriticalStructures = config.Bind<bool>("Safety", "AllowCriticalStructures", false, "Allow clearing temple/shrine/altar/builder style critical structures.");
			TargetRadius = config.Bind<float>("Targeting", "TargetRadius", 1.25f, new ConfigDescription("Fallback radius around the build cursor when vanilla hover targeting returns nothing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 5f), Array.Empty<object>()));
			ShowPrompt = config.Bind<bool>("UI", "ShowPrompt", true, "Show a small build-mode prompt for Clear This Type.");
			UseVanillaPromptSlot = config.Bind<bool>("UI", "UseVanillaPromptSlot", true, "Use the vanilla third interaction prompt slot/glyph for Clear This Type.");
			ShowConfirmationOverlay = config.Bind<bool>("UI", "ShowConfirmationOverlay", true, "Show a centered confirmation prompt before removing every matching structure.");
			RequireConfirmation = config.Bind<bool>("Safety", "RequireConfirmation", true, "Require pressing Clear Type twice before removing every matching structure.");
			ConfirmationSeconds = config.Bind<float>("Safety", "ConfirmationSeconds", 3f, new ConfigDescription("Seconds the remove-all confirmation remains active.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f), Array.Empty<object>()));
			RefundBuildSiteMaterials = config.Bind<bool>("Safety", "RefundBuildSiteMaterials", true, "Refund the full normal cost directly to inventory when Remove All clears unfinished build sites.");
		}
	}
}