using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("VHModpackFix")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.24.0")]
[assembly: AssemblyInformationalVersion("1.1.24")]
[assembly: AssemblyProduct("VHModpackFix")]
[assembly: AssemblyTitle("VHModpackFix")]
[assembly: AssemblyVersion("1.1.24.0")]
namespace Obelisk.VHModpackFix;

internal static class AAABuildMenuLifecycleFixes
{
	private const string PluginGuid = "Azumatt.AAABuildMenu";

	private const string EnhancedMenuTypeName = "AAABuildMenu.EnhancedBuildMenu";

	private const string PatchesTypeName = "AAABuildMenu.EnhancedBuildMenuPatches";

	private const string PinnedTrackerTypeName = "AAABuildMenu.PinnedRecipeTracker";

	private static readonly string[] HudReferenceFields = new string[29]
	{
		"_searchBarObject", "_searchInputField", "_scrollRect", "_clearSearchButton", "_filterButtonRow", "_allButton", "_canCraftButton", "_missingMaterialsButton", "_favoritesButton", "_recentButton",
		"_sortButton", "_sortButtonText", "_matchCountText", "_materialsButton", "_materialsDropdown", "_materialsSearchField", "_searchDebounceCoroutine", "_uiFont", "_tooltipPrefab", "_buttonSprite",
		"_hud", "_resizeHandle", "_moveHandle", "_vanillaButtonSprite", "SelectedPiece", "_materialsListContent", "_favoriteBorderSprite", "_allSprites", "_clickSfxPrefab"
	};

	private static readonly string[] HudCollectionFields = new string[7] { "_selectedMaterials", "_favoriteStars", "_favoriteBorders", "_pinIndicators", "_prefabNameCache", "_categoryMasters", "_spriteCache" };

	private static ConfigEntry<bool> _enabled;

	private static Type _enhancedMenuType;

	private static Type _patchesType;

	private static Type _pinnedTrackerType;

	private static FieldInfo _initializedField;

	private static FieldInfo _hudField;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Expected O, but got Unknown
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Expected O, but got Unknown
		_enabled = ConfigLayout.Bind(config, "AAABuildMenu", "Restore enhanced menu after world re-entry", defaultValue: true, "Clears only AAABuildMenu's HUD-bound static state when Valheim destroys a world HUD. Search, filters, the expanded grid, pin tracker, and controls are then created for the next world HUD. Favorites and saved settings are preserved. Restart Valheim after changing this setting.", "AAABuildMenu compatibility");
		if (!_enabled.Value || !Chainloader.PluginInfos.ContainsKey("Azumatt.AAABuildMenu"))
		{
			return;
		}
		_enhancedMenuType = AccessTools.TypeByName("AAABuildMenu.EnhancedBuildMenu");
		_patchesType = AccessTools.TypeByName("AAABuildMenu.EnhancedBuildMenuPatches");
		_pinnedTrackerType = AccessTools.TypeByName("AAABuildMenu.PinnedRecipeTracker");
		if (_enhancedMenuType == null)
		{
			VHModpackFixPlugin.LogWarning("AAABuildMenu lifecycle type 'AAABuildMenu.EnhancedBuildMenu' was not found; the re-entry fix was skipped.", null);
			return;
		}
		_initializedField = AccessTools.Field(_enhancedMenuType, "_isInitialized");
		_hudField = AccessTools.Field(_enhancedMenuType, "_hud");
		MethodInfo methodInfo = AccessTools.Method(typeof(Hud), "Awake", (Type[])null, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(Hud), "OnDestroy", (Type[])null, (Type[])null);
		if (_initializedField == null || _hudField == null || methodInfo == null || methodInfo2 == null)
		{
			VHModpackFixPlugin.LogWarning("AAABuildMenu lifecycle targets do not match the supported 1.0.1 layout; the re-entry fix was skipped.", null);
			return;
		}
		try
		{
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(AAABuildMenuLifecycleFixes), "HudAwakePrefix", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(AAABuildMenuLifecycleFixes), "HudOnDestroyPostfix", (Type[])null, (Type[])null))
			{
				priority = 0
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			VHModpackFixPlugin.LogInfo("AAABuildMenu world re-entry lifecycle repair installed.");
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("Could not install the AAABuildMenu world re-entry lifecycle repair", exception);
		}
	}

	private static void HudAwakePrefix(Hud __instance)
	{
		if (IsEnabled() && IsInitialized() && _hudField.GetValue(null) != __instance)
		{
			ResetHudState();
		}
	}

	private static void HudOnDestroyPostfix(Hud __instance)
	{
		if (IsEnabled() && _hudField.GetValue(null) == __instance)
		{
			ResetHudState();
		}
	}

	private static void ResetHudState()
	{
		try
		{
			_initializedField.SetValue(null, false);
			for (int i = 0; i < HudReferenceFields.Length; i++)
			{
				SetStaticField(_enhancedMenuType, HudReferenceFields[i], null);
			}
			for (int j = 0; j < HudCollectionFields.Length; j++)
			{
				ClearStaticCollection(_enhancedMenuType, HudCollectionFields[j]);
			}
			SetStaticField(_enhancedMenuType, "_origCaptured", false);
			SetStaticField(_enhancedMenuType, "_maskAdjusted", false);
			SetStaticField(_enhancedMenuType, "_origMaskCaptured", false);
			SetStaticField(_enhancedMenuType, "_vanillaButtonUsesSpriteSwap", false);
			SetStaticField(_enhancedMenuType, "_vanillaButtonResolved", false);
			SetStaticField(_enhancedMenuType, "_hasVanillaButton", false);
			SetStaticField(_enhancedMenuType, "_origWinCaptured", false);
			SetStaticField(_enhancedMenuType, "_sfxResolved", false);
			SetStaticField(_enhancedMenuType, "Columns", 15);
			FieldInfo fieldInfo = AccessTools.Field(_enhancedMenuType, "_lastScrollCategory");
			if (fieldInfo != null)
			{
				fieldInfo.SetValue(null, Enum.ToObject(fieldInfo.FieldType, -999));
			}
			ResetFilterState();
			AccessTools.Property(_enhancedMenuType, "NeedsRefresh")?.SetValue(null, true, null);
			SetStaticField(_patchesType, "_menuWasVisible", false);
			ResetPinnedTrackerState();
			VHModpackFixPlugin.LogInfo("AAABuildMenu HUD-bound state cleared for the next world.");
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("Could not clear stale AAABuildMenu HUD state", exception);
		}
	}

	private static void ResetFilterState()
	{
		object obj = AccessTools.Field(_enhancedMenuType, "_currentFilter")?.GetValue(null);
		if (obj != null)
		{
			SetInstanceProperty(obj, "SearchTerm", string.Empty);
			SetInstanceProperty(obj, "ShowOnlyCraftable", false);
			SetInstanceProperty(obj, "ShowMissingMaterials", false);
			SetInstanceProperty(obj, "ShowFavoritesOnly", false);
			SetInstanceProperty(obj, "ShowRecentOnly", false);
			SetInstanceProperty(obj, "ShowAll", false);
		}
	}

	private static void ResetPinnedTrackerState()
	{
		if (!(_pinnedTrackerType == null))
		{
			SetStaticField(_pinnedTrackerType, "_root", null);
			SetStaticField(_pinnedTrackerType, "_rootRect", null);
			SetStaticField(_pinnedTrackerType, "_contentRoot", null);
			SetStaticField(_pinnedTrackerType, "_title", null);
			SetStaticField(_pinnedTrackerType, "_font", null);
			SetStaticField(_pinnedTrackerType, "_nextRefresh", 0f);
			ClearStaticCollection(_pinnedTrackerType, "_pieceCache");
			ClearStaticCollection(_pinnedTrackerType, "_rows");
			ClearStaticCollection(_pinnedTrackerType, "_shownPins");
		}
	}

	private static void SetStaticField(Type type, string fieldName, object value)
	{
		if (!(type == null))
		{
			AccessTools.Field(type, fieldName)?.SetValue(null, value);
		}
	}

	private static void ClearStaticCollection(Type type, string fieldName)
	{
		if (!(type == null))
		{
			object obj = AccessTools.Field(type, fieldName)?.GetValue(null);
			obj?.GetType().GetMethod("Clear", Type.EmptyTypes)?.Invoke(obj, null);
		}
	}

	private static void SetInstanceProperty(object instance, string propertyName, object value)
	{
		instance.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public)?.SetValue(instance, value, null);
	}

	private static bool IsEnabled()
	{
		return _enabled?.Value ?? false;
	}

	private static bool IsInitialized()
	{
		object obj = _initializedField?.GetValue(null);
		bool flag = default(bool);
		int num;
		if (obj is bool)
		{
			flag = (bool)obj;
			num = 1;
		}
		else
		{
			num = 0;
		}
		return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
	}
}
internal static class AdventureBackpacksAutoStoreCompat
{
	[HarmonyPatch(typeof(Player), "Message")]
	private static class PlayerMessagePatch
	{
		private static bool Prefix(MessageType type, string msg)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return !ShouldSuppressMessage(type, msg);
		}
	}

	private const string VanillaContainerType = "AzuAutoStore.Interfaces.VanillaContainers";

	private const string KgDrawerType = "AzuAutoStore.Interfaces.kgDrawer";

	private const string BackpackContainerType = "AzuAutoStore.Interfaces.BackpackContainer";

	private const string BackpackInventoryMarker = "$vapok_mod_level";

	private const string FavoriteBorderName = "AzuAutoStoreFavoritingBorder";

	private const string BackpackFavoriteDataKey = "obelisk.vhmodpackfix.backpackFavorite";

	private const string EpicLootCustomDataPrefix = "randyknapp.mods.epicloot#";

	private static ConfigEntry<bool> _autoStoreEnabled;

	private static ConfigEntry<bool> _pickupRoutingEnabled;

	private static MethodInfo _getEquippedBackpack;

	private static MethodInfo _getBackpackInventory;

	private static MethodInfo _isBackpackItem;

	private static MethodInfo _inventoryChanged;

	private static FieldInfo _inventoryGuiCurrentContainer;

	private static FieldInfo _inventoryGuiDragObject;

	private static FieldInfo _containerNetworkView;

	private static MethodInfo _containerCheckAccess;

	private static MethodInfo _getNearbyContainers;

	private static MethodInfo _storeToContainer;

	private static MethodInfo _vanillaContainerGetInventory;

	private static PropertyInfo _containerGameObject;

	private static FieldInfo _playerRange;

	private static MethodInfo _isItemNameOrSlotFavorite;

	private static MethodInfo _createFavoriteBorder;

	private static FieldInfo _favoriteBorderColor;

	private static FieldInfo _favoritingModifier1;

	private static FieldInfo _favoritingModifier2;

	private static FieldInfo _favoritingToggleState;

	private static FieldInfo _inventoryGridInventory;

	private static FieldInfo _inventoryGridElements;

	private static FieldInfo _elementQueuedImage;

	private static MethodInfo _inventoryGridGetButtonPos;

	private static bool _backpackReady;

	private static bool _autoStoreReady;

	private static bool _autoStorePatched;

	private static bool _pickupPatched;

	private static bool _containerTransferPatched;

	private static bool _loadRecoveryPatched;

	private static bool _backpackSaveHotPathPatched;

	private static bool _favoritePatched;

	private static bool _pickupApiFailureLogged;

	private static bool _favoriteFailureLogged;

	private static bool _favoriteBordersDirty = true;

	private static Inventory _lastBorderInventory;

	private static InventoryGrid _lastBorderGrid;

	private static Image _lastBorderFirstQueuedImage;

	private static int _lastBorderElementCount = -1;

	private static int _pickupBackpackCacheFrame = -1;

	private static Player _pickupBackpackCachePlayer;

	private static Inventory _pickupBackpackCacheInventory;

	[ThreadStatic]
	private static bool _tryStoreScope;

	[ThreadStatic]
	private static bool _suppressAzuFailureMessage;

	[ThreadStatic]
	private static int _backpackStored;

	[ThreadStatic]
	private static Inventory _activeStoreInventory;

	[ThreadStatic]
	private static ItemData _activeStoreItem;

	[ThreadStatic]
	private static Vector2i _activeStoreOriginalPosition;

	[ThreadStatic]
	private static object[] _playerInvokeArguments;

	[ThreadStatic]
	private static object[] _itemInvokeArguments;

	[ThreadStatic]
	private static object[] _nearbyInvokeArguments;

	[ThreadStatic]
	private static object[] _storeInvokeArguments;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		_autoStoreEnabled = ConfigLayout.Bind(config, "AdventureBackpacks", "AdventureBackpacks AzuAutoStore compatibility", defaultValue: true, "Lets AzuAutoStore move eligible items from your equipped AdventureBackpacks backpack into nearby storage. Favorite items remain protected.", "Fixes");
		_pickupRoutingEnabled = ConfigLayout.Bind(config, "AdventureBackpacks", "Auto-pick matching items into AdventureBackpacks", defaultValue: false, "When the equipped backpack already contains an item type, sends whole matching stacks there during automatic pickup, manual pickup, and quick transfer from an opened container. Epic Loot stack data is supported; unknown special data is left to the normal inventory for safety.", "Experimental");
		if (harmony == null || !ResolveBackpackApi())
		{
			return;
		}
		if (!_loadRecoveryPatched)
		{
			PatchBackpackLoadRecovery(harmony);
		}
		if (!_backpackSaveHotPathPatched)
		{
			PatchBackpackSaveHotPath(harmony);
		}
		if (!_pickupPatched)
		{
			PatchPickupRouting(harmony);
		}
		if (!_containerTransferPatched)
		{
			PatchContainerTransfers(harmony);
		}
		if (ResolveAutoStoreApi())
		{
			if (!_autoStorePatched)
			{
				PatchAutoStore(harmony);
			}
			if (!_favoritePatched)
			{
				PatchFavoriteSupport(harmony);
			}
		}
	}

	private static bool ResolveBackpackApi()
	{
		if (_backpackReady)
		{
			return true;
		}
		Type type = FindLoadedType("AdventureBackpacks.Extensions.PlayerExtensions");
		Type type2 = FindLoadedType("AdventureBackpacks.Extensions.ItemDataExtensions");
		_getEquippedBackpack = ((type == null) ? null : AccessTools.Method(type, "GetEquippedBackpack", new Type[1] { typeof(Player) }, (Type[])null));
		Type type3 = _getEquippedBackpack?.ReturnType;
		_getBackpackInventory = ((type3 == null) ? null : AccessTools.Method(type3, "GetInventory", Type.EmptyTypes, (Type[])null));
		_isBackpackItem = ((type2 == null) ? null : AccessTools.Method(type2, "IsBackpack", new Type[1] { typeof(ItemData) }, (Type[])null));
		_inventoryChanged = AccessTools.Method(typeof(Inventory), "Changed", Type.EmptyTypes, (Type[])null);
		_inventoryGuiCurrentContainer = AccessTools.Field(typeof(InventoryGui), "m_currentContainer");
		_inventoryGuiDragObject = AccessTools.Field(typeof(InventoryGui), "m_dragGo");
		_containerNetworkView = AccessTools.Field(typeof(Container), "m_nview");
		_containerCheckAccess = AccessTools.Method(typeof(Container), "CheckAccess", new Type[1] { typeof(long) }, (Type[])null);
		_backpackReady = _getEquippedBackpack != null && _getBackpackInventory != null && _inventoryChanged != null;
		return _backpackReady;
	}

	private static bool ResolveAutoStoreApi()
	{
		if (_autoStoreReady)
		{
			return true;
		}
		Type type = FindLoadedType("AzuAutoStore.Util.Boxes");
		Type type2 = FindLoadedType("AzuAutoStore.Util.Functions");
		Type type3 = FindLoadedType("AzuAutoStore.Interfaces.IContainer");
		Type type4 = FindLoadedType("AzuAutoStore.Interfaces.VanillaContainers");
		Type type5 = FindLoadedType("AzuAutoStore.AzuAutoStorePlugin");
		if (type == null || type2 == null || type3 == null)
		{
			return false;
		}
		_getNearbyContainers = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo method)
		{
			if (method.Name != "GetNearbyContainers" || !method.IsGenericMethodDefinition)
			{
				return false;
			}
			ParameterInfo[] parameters = method.GetParameters();
			return parameters.Length == 2 && parameters[1].ParameterType == typeof(float);
		})?.MakeGenericMethod(typeof(Player));
		_storeToContainer = AccessTools.DeclaredMethod(type2, "StoreToContainer", new Type[3]
		{
			type3,
			typeof(ItemData),
			typeof(Inventory)
		}, (Type[])null);
		_vanillaContainerGetInventory = ((type4 == null) ? null : AccessTools.Method(type4, "GetInventory", Type.EmptyTypes, (Type[])null));
		_containerGameObject = AccessTools.Property(type3, "gameObject");
		_playerRange = ((type5 == null) ? null : AccessTools.Field(type5, "PlayerRange"));
		ResolveFavoriteApi(type5);
		_autoStoreReady = _isBackpackItem != null && _getNearbyContainers != null && _storeToContainer != null;
		return _autoStoreReady;
	}

	private static void ResolveFavoriteApi(Type pluginType)
	{
		Type type = FindLoadedType("AzuAutoStore.Patches.Favoriting.UserConfig");
		Type type2 = FindLoadedType("AzuAutoStore.Patches.Favoriting.FavoritingMode");
		Type type3 = FindLoadedType("AzuAutoStore.Patches.Favoriting.BorderRenderer");
		_isItemNameOrSlotFavorite = ((type == null) ? null : AccessTools.Method(type, "IsItemNameOrSlotFavorited", new Type[1] { typeof(ItemData) }, (Type[])null));
		_createFavoriteBorder = ((type3 == null) ? null : AccessTools.Method(type3, "CreateBorderImage", new Type[1] { typeof(Image) }, (Type[])null));
		_favoriteBorderColor = ((pluginType == null) ? null : AccessTools.Field(pluginType, "BorderColorFavoritedItem"));
		_favoritingModifier1 = ((pluginType == null) ? null : AccessTools.Field(pluginType, "FavoritingModifierKeybind1"));
		_favoritingModifier2 = ((pluginType == null) ? null : AccessTools.Field(pluginType, "FavoritingModifierKeybind2"));
		_favoritingToggleState = ((type2 == null) ? null : AccessTools.Field(type2, "hasCurrentlyToggledFavoriting"));
		_inventoryGridInventory = AccessTools.Field(typeof(InventoryGrid), "m_inventory");
		_inventoryGridElements = AccessTools.Field(typeof(InventoryGrid), "m_elements");
		_inventoryGridGetButtonPos = AccessTools.Method(typeof(InventoryGrid), "GetButtonPos", new Type[1] { typeof(GameObject) }, (Type[])null);
	}

	private static void PatchAutoStore(Harmony harmony)
	{
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Expected O, but got Unknown
		//IL_00f1: Expected O, but got Unknown
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0123: Expected O, but got Unknown
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Expected O, but got Unknown
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c7: Expected O, but got Unknown
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: Expected O, but got Unknown
		Type type = FindLoadedType("AzuAutoStore.Util.Functions");
		Type type2 = FindLoadedType("AzuAutoStore.Patches.ContainerAwakePatch");
		MethodInfo methodInfo = AccessTools.Method(type, "TryStore", Type.EmptyTypes, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(type, "StoreSuccess", new Type[1] { typeof(int) }, (Type[])null);
		MethodInfo methodInfo3 = AccessTools.Method(type2, "TryAddContainer", new Type[1] { typeof(Container) }, (Type[])null);
		MethodInfo methodInfo4 = AccessTools.Method(typeof(Inventory), "Changed", Type.EmptyTypes, (Type[])null);
		if (!(methodInfo == null) && !(methodInfo2 == null) && !(methodInfo4 == null))
		{
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "TryStorePrefix", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "TryStoreFinalizer", (Type[])null, (Type[])null))
			{
				priority = 0
			}, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "StoreSuccessPrefix", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)_storeToContainer, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "SkipEquippedBackpackContainerPrefix", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			if (methodInfo3 != null)
			{
				harmony.Patch((MethodBase)methodInfo3, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "SkipPlayerContainerRegistrationPrefix", (Type[])null, (Type[])null))
				{
					priority = 800
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			harmony.Patch((MethodBase)methodInfo4, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "InventoryChangedPrefix", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			_autoStorePatched = true;
		}
	}

	private static void PatchPickupRouting(Harmony harmony)
	{
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Expected O, but got Unknown
		MethodInfo methodInfo = AccessTools.Method(typeof(Humanoid), "Pickup", new Type[3]
		{
			typeof(GameObject),
			typeof(bool),
			typeof(bool)
		}, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(Player), "AutoPickup", new Type[1] { typeof(float) }, (Type[])null);
		if (methodInfo == null || methodInfo2 == null)
		{
			VHModpackFixPlugin.LogWarning("AdventureBackpacks pickup routing could not find the current Valheim pickup methods", null);
			return;
		}
		try
		{
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "PickupAddTranspiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			PatchAutoPickupMethod(harmony, methodInfo2);
			MethodInfo methodInfo3 = FindLoadedType("Valheim_Build_Camera.Utils")?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo method)
			{
				if (method.Name != "AutoPickup")
				{
					return false;
				}
				ParameterInfo[] parameters = method.GetParameters();
				return parameters.Length == 2 && parameters[0].ParameterType == typeof(float) && parameters[1].ParameterType == typeof(GameCamera).MakeByRefType();
			});
			if (methodInfo3 != null)
			{
				PatchAutoPickupMethod(harmony, methodInfo3);
			}
			_pickupPatched = true;
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("AdventureBackpacks pickup routing could not be installed", Unwrap(exception));
		}
	}

	private static void PatchContainerTransfers(Harmony harmony)
	{
		//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_0099: Expected O, but got Unknown
		//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_00d4: Expected O, but got Unknown
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		//IL_017f: Unknown result type (might be due to invalid IL or missing references)
		//IL_018e: Expected O, but got Unknown
		//IL_018e: Expected O, but got Unknown
		try
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(Inventory), "MoveItemToThis", new Type[2]
			{
				typeof(Inventory),
				typeof(ItemData)
			}, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Inventory), "MoveAll", new Type[1] { typeof(Inventory) }, (Type[])null);
			if (methodInfo != null)
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "MoveItemToThisPrefix", (Type[])null, (Type[])null))
				{
					priority = 800
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			if (methodInfo2 != null)
			{
				harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "MoveAllPrefix", (Type[])null, (Type[])null))
				{
					priority = 800
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			Type type = FindLoadedType("InventorySlots.InventorySlotsPlugin");
			MethodInfo methodInfo3 = ((type == null) ? null : AccessTools.Method(type, "SafeTakeAllItems", new Type[4]
			{
				typeof(Player),
				typeof(Inventory),
				typeof(Inventory),
				typeof(bool)
			}, (Type[])null));
			if (methodInfo3 != null)
			{
				harmony.Patch((MethodBase)methodInfo3, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "SafeTakeAllPrefix", (Type[])null, (Type[])null))
				{
					priority = 800
				}, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "SafeTakeAllPostfix", (Type[])null, (Type[])null))
				{
					priority = 0
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			_containerTransferPatched = methodInfo != null || methodInfo2 != null;
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("AdventureBackpacks container pickup routing could not be installed", Unwrap(exception));
		}
	}

	private static void PatchBackpackLoadRecovery(Harmony harmony)
	{
		//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_008c: Expected O, but got Unknown
		MethodInfo methodInfo = AccessTools.Method(typeof(Inventory), "AddItem", new Type[4]
		{
			typeof(ItemData),
			typeof(int),
			typeof(int),
			typeof(int)
		}, (Type[])null);
		if (methodInfo == null)
		{
			return;
		}
		try
		{
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "RepairLoadedBackpackSlotPrefix", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			_loadRecoveryPatched = true;
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("AdventureBackpacks legacy slot recovery could not be installed", Unwrap(exception));
		}
	}

	private static void PatchBackpackSaveHotPath(Harmony harmony)
	{
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Expected O, but got Unknown
		MethodInfo methodInfo = AccessTools.DeclaredMethod(_getEquippedBackpack?.DeclaringType?.Assembly.GetType("AdventureBackpacks.Patches.InventoryPatches+InventoryChangedPatch", throwOnError: false), "Postfix", new Type[1] { typeof(Inventory) }, (Type[])null);
		if (methodInfo == null)
		{
			return;
		}
		try
		{
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "RemoveUnusedBackpackStackTraceTranspiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			_backpackSaveHotPathPatched = true;
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("AdventureBackpacks save-path optimization could not be installed", Unwrap(exception));
		}
	}

	private static void PatchFavoriteSupport(Harmony harmony)
	{
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Expected O, but got Unknown
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Expected O, but got Unknown
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Expected O, but got Unknown
		if (_isItemNameOrSlotFavorite == null || _inventoryGridGetButtonPos == null || _inventoryGridInventory == null || _inventoryGridElements == null)
		{
			return;
		}
		MethodInfo methodInfo = AccessTools.Method(typeof(InventoryGrid), "OnLeftClick", new Type[1] { typeof(UIInputHandler) }, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(InventoryGrid), "UpdateGui", new Type[2]
		{
			typeof(Player),
			typeof(ItemData)
		}, (Type[])null);
		if (methodInfo == null || methodInfo2 == null)
		{
			return;
		}
		try
		{
			HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "BackpackLeftClickPrefix", (Type[])null, (Type[])null));
			val.priority = 800;
			val.before = new string[3] { "Azumatt.AzuAutoStore", "sighsorry.InventorySlots", "goldenrevolver.quick_stack_store" };
			harmony.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val = new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "RenderFavoriteBordersPostfix", (Type[])null, (Type[])null));
			val.priority = 0;
			val.after = new string[2] { "Azumatt.AzuAutoStore", "goldenrevolver.quick_stack_store" };
			harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)_isItemNameOrSlotFavorite, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "AzuFavoriteCheckPrefix", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			_favoritePatched = true;
		}
		catch (Exception exception)
		{
			LogFavoriteFailure("AdventureBackpacks favorite-item support could not be installed", exception);
		}
	}

	private static void PatchAutoPickupMethod(Harmony harmony, MethodInfo method)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Expected O, but got Unknown
		harmony.Patch((MethodBase)method, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "AutoPickupCanAddTranspiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
	}

	private static IEnumerable<CodeInstruction> PickupAddTranspiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod)
	{
		MethodInfo target = AccessTools.Method(typeof(Inventory), "AddItem", new Type[1] { typeof(ItemData) }, (Type[])null);
		MethodInfo replacement = AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "AddPickupItem", (Type[])null, (Type[])null);
		return ReplaceSingleCall(instructions, target, replacement, __originalMethod);
	}

	private static IEnumerable<CodeInstruction> AutoPickupCanAddTranspiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod)
	{
		MethodInfo target = AccessTools.Method(typeof(Inventory), "CanAddItem", new Type[2]
		{
			typeof(ItemData),
			typeof(int)
		}, (Type[])null);
		MethodInfo replacement = AccessTools.Method(typeof(AdventureBackpacksAutoStoreCompat), "CanAddPickupItem", (Type[])null, (Type[])null);
		return ReplaceSingleCall(instructions, target, replacement, __originalMethod);
	}

	private static IEnumerable<CodeInstruction> ReplaceSingleCall(IEnumerable<CodeInstruction> instructions, MethodInfo target, MethodInfo replacement, MethodBase original)
	{
		List<CodeInstruction> list = instructions.ToList();
		for (int i = 0; i < list.Count; i++)
		{
			if (CodeInstructionExtensions.Calls(list[i], target))
			{
				list[i].opcode = OpCodes.Call;
				list[i].operand = replacement;
				return list;
			}
		}
		VHModpackFixPlugin.LogWarning("AdventureBackpacks pickup routing found no compatible call in " + original?.DeclaringType?.FullName + "." + original?.Name, null);
		return list;
	}

	private static IEnumerable<CodeInstruction> RemoveUnusedBackpackStackTraceTranspiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod)
	{
		List<CodeInstruction> list = instructions.ToList();
		ConstructorInfo objB = AccessTools.Constructor(typeof(StackTrace), Type.EmptyTypes, false);
		int num = -1;
		int num2 = 0;
		for (int i = 0; i < list.Count - 1; i++)
		{
			if (!(list[i].opcode != OpCodes.Newobj) && object.Equals(list[i].operand, objB) && !(list[i + 1].opcode != OpCodes.Pop))
			{
				num = i;
				num2++;
			}
		}
		if (num2 != 1)
		{
			VHModpackFixPlugin.LogWarning($"AdventureBackpacks save-path optimization expected one unused StackTrace in {__originalMethod?.DeclaringType?.FullName}.{__originalMethod?.Name}, found {num2}", null);
			return list;
		}
		list[num].opcode = OpCodes.Nop;
		list[num].operand = null;
		list[num + 1].opcode = OpCodes.Nop;
		list[num + 1].operand = null;
		return list;
	}

	private static bool CanAddPickupItem(Inventory regularInventory, ItemData item, int stack)
	{
		if (regularInventory == null || item == null)
		{
			if (regularInventory != null && item != null)
			{
				return regularInventory.CanAddItem(item, stack);
			}
			return false;
		}
		if (regularInventory.CanAddItem(item, stack))
		{
			return true;
		}
		int num = ((stack <= 0) ? item.m_stack : stack);
		if (TryGetPickupBackpack(regularInventory, item, out var backpackInventory, out var capacity) && capacity >= num)
		{
			return backpackInventory.CanAddItem(item, num);
		}
		return false;
	}

	private static bool AddPickupItem(Inventory regularInventory, ItemData item)
	{
		ConfigEntry<bool> pickupRoutingEnabled = _pickupRoutingEnabled;
		if (pickupRoutingEnabled == null || !pickupRoutingEnabled.Value || regularInventory == null || item == null || !TryGetPickupBackpack(regularInventory, item, out var backpackInventory, out var capacity) || capacity < item.m_stack || !backpackInventory.CanAddItem(item, item.m_stack))
		{
			if (regularInventory != null && item != null)
			{
				return regularInventory.AddItem(item);
			}
			return false;
		}
		return backpackInventory.AddItem(item);
	}

	private static bool MoveItemToThisPrefix(Inventory __instance, Inventory fromInventory, ItemData item)
	{
		ConfigEntry<bool> pickupRoutingEnabled = _pickupRoutingEnabled;
		if (pickupRoutingEnabled == null || !pickupRoutingEnabled.Value || !IsCurrentOpenedContainerTransfer(__instance, fromInventory) || !TryMoveWholeStackToBackpack(__instance, fromInventory, item))
		{
			return true;
		}
		return false;
	}

	private static void MoveAllPrefix(Inventory __instance, Inventory fromInventory)
	{
		ConfigEntry<bool> pickupRoutingEnabled = _pickupRoutingEnabled;
		if (pickupRoutingEnabled != null && pickupRoutingEnabled.Value)
		{
			RouteCurrentContainerItems(Player.m_localPlayer, __instance, fromInventory);
		}
	}

	private static void SafeTakeAllPrefix(Player player, Inventory playerInventory, Inventory containerInventory, out int __state)
	{
		ConfigEntry<bool> pickupRoutingEnabled = _pickupRoutingEnabled;
		__state = ((pickupRoutingEnabled != null && pickupRoutingEnabled.Value) ? RouteCurrentContainerItems(player, playerInventory, containerInventory) : 0);
	}

	private static void SafeTakeAllPostfix(ref int __result, int __state)
	{
		if (__state > 0)
		{
			__result += __state;
		}
	}

	private static int RouteCurrentContainerItems(Player player, Inventory playerInventory, Inventory containerInventory)
	{
		if ((Object)(object)player == (Object)null || playerInventory == null || containerInventory == null || player != Player.m_localPlayer || playerInventory != ((Humanoid)player).GetInventory() || !IsCurrentOpenedContainerTransfer(playerInventory, containerInventory))
		{
			return 0;
		}
		int num = 0;
		List<ItemData> list = new List<ItemData>(containerInventory.GetAllItems());
		list.Sort(delegate(ItemData left, ItemData right)
		{
			int num3 = left.m_gridPos.y.CompareTo(right.m_gridPos.y);
			return (num3 == 0) ? left.m_gridPos.x.CompareTo(right.m_gridPos.x) : num3;
		});
		for (int num2 = 0; num2 < list.Count; num2++)
		{
			ItemData item = list[num2];
			if (TryMoveWholeStackToBackpack(playerInventory, containerInventory, item))
			{
				num++;
			}
		}
		return num;
	}

	private static bool IsCurrentOpenedContainerTransfer(Inventory playerInventory, Inventory containerInventory)
	{
		Player localPlayer = Player.m_localPlayer;
		InventoryGui instance = InventoryGui.instance;
		Container val = (Container)(((Object)(object)instance == (Object)null) ? null : /*isinst with value type is only supported in some contexts*/);
		if ((Object)(object)localPlayer == (Object)null || (Object)(object)val == (Object)null || playerInventory == null || containerInventory == null || playerInventory != ((Humanoid)localPlayer).GetInventory() || val.GetInventory() != containerInventory || (Object)(object)((Component)val).GetComponent<TombStone>() != (Object)null || !CanMutateOpenedContainerDirectly(val, localPlayer))
		{
			return false;
		}
		Inventory val2 = TryGetEquippedBackpackInventory(localPlayer);
		if (val2 != null)
		{
			return containerInventory != val2;
		}
		return false;
	}

	private static bool CanMutateOpenedContainerDirectly(Container container, Player player)
	{
		try
		{
			if (_containerCheckAccess != null)
			{
				object obj = _containerCheckAccess.Invoke(container, new object[1] { player.GetPlayerID() });
				if (obj is bool && !(bool)obj)
				{
					return false;
				}
			}
			object? obj2 = _containerNetworkView?.GetValue(container);
			ZNetView val = (ZNetView)((obj2 is ZNetView) ? obj2 : null);
			return (Object)(object)val == (Object)null || !val.IsValid() || val.IsOwner();
		}
		catch
		{
			return false;
		}
	}

	private static bool TryMoveWholeStackToBackpack(Inventory playerInventory, Inventory sourceInventory, ItemData item)
	{
		if (item == null || item.m_stack <= 0 || !sourceInventory.ContainsItem(item) || !TryGetPickupBackpack(playerInventory, item, out var backpackInventory, out var capacity) || sourceInventory == backpackInventory)
		{
			return false;
		}
		int stack = item.m_stack;
		if (capacity < stack || !backpackInventory.CanAddItem(item, stack))
		{
			return false;
		}
		List<ItemData> list = new List<ItemData>(backpackInventory.GetAllItems());
		int[] array = new int[list.Count];
		for (int i = 0; i < list.Count; i++)
		{
			array[i] = list[i].m_stack;
		}
		ItemData val = item.Clone();
		val.m_stack = stack;
		if (!backpackInventory.AddItem(val))
		{
			RestoreBackpackTransfer(backpackInventory, val, list, array);
			VHModpackFixPlugin.LogWarning("AdventureBackpacks rejected a pre-checked whole-stack transfer; the normal inventory transfer was kept", null);
			return false;
		}
		sourceInventory.RemoveItem(item);
		if (sourceInventory.ContainsItem(item))
		{
			RestoreBackpackTransfer(backpackInventory, val, list, array);
			VHModpackFixPlugin.LogWarning("AdventureBackpacks accepted an item but its source container could not remove the original stack", null);
			return false;
		}
		return true;
	}

	private static void RestoreBackpackTransfer(Inventory backpackInventory, ItemData transfer, List<ItemData> previousItems, int[] previousStacks)
	{
		List<ItemData> allItems = backpackInventory.GetAllItems();
		allItems.Remove(transfer);
		for (int i = 0; i < previousItems.Count; i++)
		{
			ItemData val = previousItems[i];
			if (allItems.Contains(val))
			{
				val.m_stack = previousStacks[i];
			}
		}
		_inventoryChanged.Invoke(backpackInventory, null);
	}

	private static bool TryGetPickupBackpack(Inventory regularInventory, ItemData item, out Inventory backpackInventory, out int capacity)
	{
		backpackInventory = null;
		capacity = 0;
		Player localPlayer = Player.m_localPlayer;
		ConfigEntry<bool> pickupRoutingEnabled = _pickupRoutingEnabled;
		if (pickupRoutingEnabled == null || !pickupRoutingEnabled.Value || (Object)(object)localPlayer == (Object)null || regularInventory != ((Humanoid)localPlayer).GetInventory() || item?.m_shared == null || item.m_stack <= 0 || item.m_shared.m_maxStackSize <= 1 || item.m_shared.m_questItem || item.IsWeapon() || HasUnsafeCustomData(item))
		{
			return false;
		}
		backpackInventory = GetPickupBackpackInventory(localPlayer);
		if (backpackInventory == null || backpackInventory == regularInventory)
		{
			return false;
		}
		List<ItemData> allItems = backpackInventory.GetAllItems();
		if (allItems == null || allItems.Count == 0)
		{
			return false;
		}
		string name = item.m_shared.m_name;
		bool flag = false;
		bool flag2 = false;
		bool flag3 = false;
		int num = 0;
		for (int num2 = allItems.Count - 1; num2 >= 0; num2--)
		{
			ItemData val = allItems[num2];
			if (val == null || val.m_stack <= 0)
			{
				allItems.RemoveAt(num2);
				flag3 = true;
			}
			else if (val.m_shared != null && string.Equals(val.m_shared.m_name, name, StringComparison.Ordinal))
			{
				flag = true;
				if (HasUnsafeCustomData(val))
				{
					flag2 = true;
				}
				else if (val.m_quality == item.m_quality && val.m_worldLevel == item.m_worldLevel && val.m_stack < val.m_shared.m_maxStackSize)
				{
					num += val.m_shared.m_maxStackSize - val.m_stack;
				}
			}
		}
		if (flag3)
		{
			_inventoryChanged.Invoke(backpackInventory, null);
		}
		if (!flag || flag2)
		{
			return false;
		}
		int num3 = Math.Max(0, backpackInventory.GetEmptySlots());
		capacity = num + num3 * Math.Max(1, item.m_shared.m_maxStackSize);
		return capacity > 0;
	}

	private static Inventory GetPickupBackpackInventory(Player player)
	{
		int frameCount = Time.frameCount;
		if (frameCount != _pickupBackpackCacheFrame || player != _pickupBackpackCachePlayer)
		{
			_pickupBackpackCacheFrame = frameCount;
			_pickupBackpackCachePlayer = player;
			_pickupBackpackCacheInventory = TryGetEquippedBackpackInventory(player);
		}
		return _pickupBackpackCacheInventory;
	}

	private static bool HasUnsafeCustomData(ItemData item)
	{
		if (item?.m_customData == null || item.m_customData.Count == 0)
		{
			return false;
		}
		foreach (string key in item.m_customData.Keys)
		{
			if (!string.Equals(key, "obelisk.vhmodpackfix.backpackFavorite", StringComparison.Ordinal) && !key.StartsWith("randyknapp.mods.epicloot#", StringComparison.Ordinal))
			{
				return true;
			}
		}
		return false;
	}

	private static bool RepairLoadedBackpackSlotPrefix(Inventory __instance, ItemData item, int amount, ref int x, ref int y, ref bool __result)
	{
		//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_0052: 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_0065: Unknown result type (might be due to invalid IL or missing references)
		if (!IsAdventureBackpackInventory(__instance))
		{
			return true;
		}
		if (item == null || amount <= 0 || item.m_stack <= 0)
		{
			__result = false;
			return false;
		}
		int width = __instance.GetWidth();
		int height = __instance.GetHeight();
		if (x >= 0 && x < width && y >= 0 && y < height)
		{
			return true;
		}
		Vector2i val = FindFreeSlot(__instance, width, height, y);
		if (val.x >= 0)
		{
			x = val.x;
			y = val.y;
		}
		return true;
	}

	private static bool SkipEquippedBackpackContainerPrefix(object container, ref int __result)
	{
		if (!IsEquippedAdventureBackpackContainer(container))
		{
			return true;
		}
		__result = 0;
		return false;
	}

	private static bool SkipPlayerContainerRegistrationPrefix(Container container, ref bool __result)
	{
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)container == (Object)null || (Object)(object)localPlayer == (Object)null || (Object)(object)((Component)container).gameObject != (Object)(object)((Component)localPlayer).gameObject)
		{
			return true;
		}
		__result = false;
		return false;
	}

	private static void TryStorePrefix()
	{
		_tryStoreScope = false;
		_backpackStored = 0;
		ConfigEntry<bool> autoStoreEnabled = _autoStoreEnabled;
		if (autoStoreEnabled == null || !autoStoreEnabled.Value || !_autoStoreReady)
		{
			return;
		}
		try
		{
			_tryStoreScope = true;
			_backpackStored = StoreEquippedBackpack();
		}
		catch (Exception exception)
		{
			_backpackStored = 0;
			VHModpackFixPlugin.LogWarning("AdventureBackpacks/AzuAutoStore integration failed", Unwrap(exception));
		}
	}

	private static Exception TryStoreFinalizer(Exception __exception)
	{
		_tryStoreScope = false;
		_suppressAzuFailureMessage = false;
		_backpackStored = 0;
		ClearActiveStoreScope();
		return __exception;
	}

	private static void StoreSuccessPrefix(ref int total)
	{
		if (_tryStoreScope)
		{
			total += _backpackStored;
			_backpackStored = 0;
		}
	}

	private static void InventoryChangedPrefix(Inventory __instance)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		if (__instance == _activeStoreInventory && _activeStoreItem != null)
		{
			_activeStoreItem.m_gridPos = _activeStoreOriginalPosition;
		}
		if (_favoritePatched && IsAdventureBackpackInventory(__instance))
		{
			_favoriteBordersDirty = true;
		}
	}

	private static int StoreEquippedBackpack()
	{
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null)
		{
			return 0;
		}
		Inventory val = TryGetEquippedBackpackInventory(localPlayer);
		if (val == null)
		{
			return 0;
		}
		RemoveInvalidRuntimeStacks(val);
		List<ItemData> allItems = val.GetAllItems();
		if (allItems == null || allItems.Count == 0)
		{
			return 0;
		}
		object[] array = _nearbyInvokeArguments ?? (_nearbyInvokeArguments = new object[2]);
		array[0] = localPlayer;
		array[1] = GetPlayerRange();
		object obj;
		try
		{
			obj = _getNearbyContainers.Invoke(null, array);
		}
		finally
		{
			array[0] = null;
			array[1] = null;
		}
		if (!(obj is IEnumerable enumerable))
		{
			return 0;
		}
		List<ItemData> list = new List<ItemData>(allItems.Count);
		for (int i = 0; i < allItems.Count; i++)
		{
			ItemData val2 = allItems[i];
			if (val2 != null && val2.m_stack > 0 && !val2.m_equipped && !IsBackpackItem(val2) && !IsBackpackStackFavorite(val2))
			{
				list.Add(val2);
			}
		}
		int num = 0;
		foreach (object item in enumerable)
		{
			if (item == null || !IsSupportedContainer(item) || IsUnsafeSelfTarget(item, val, localPlayer))
			{
				continue;
			}
			for (int num2 = list.Count - 1; num2 >= 0; num2--)
			{
				ItemData val3 = list[num2];
				if (val3 == null || val3.m_stack <= 0 || !val.ContainsItem(val3))
				{
					list.RemoveAt(num2);
				}
				else
				{
					num += StoreItem(item, val3, val, out var stopPass);
					if (stopPass)
					{
						return num;
					}
					if (val3.m_stack <= 0 || !val.ContainsItem(val3))
					{
						list.RemoveAt(num2);
					}
				}
			}
			if (list.Count == 0)
			{
				break;
			}
		}
		return num;
	}

	private static int StoreItem(object container, ItemData sourceItem, Inventory sourceInventory, out bool stopPass)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: 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)
		stopPass = false;
		int stack = sourceItem.m_stack;
		Vector2i gridPos = sourceItem.m_gridPos;
		Exception ex = null;
		_activeStoreInventory = sourceInventory;
		_activeStoreItem = sourceItem;
		_activeStoreOriginalPosition = gridPos;
		sourceItem.m_gridPos = new Vector2i(-1, -1);
		_suppressAzuFailureMessage = true;
		object[] array = _storeInvokeArguments ?? (_storeInvokeArguments = new object[3]);
		array[0] = container;
		array[1] = sourceItem;
		array[2] = sourceInventory;
		try
		{
			_storeToContainer.Invoke(null, array);
		}
		catch (Exception exception)
		{
			ex = Unwrap(exception);
		}
		finally
		{
			sourceItem.m_gridPos = gridPos;
			_suppressAzuFailureMessage = false;
			array[0] = null;
			array[1] = null;
			array[2] = null;
			ClearActiveStoreScope();
		}
		if (sourceItem.m_stack <= 0 && sourceInventory.ContainsItem(sourceItem) && !RemoveZeroStack(sourceInventory, sourceItem))
		{
			stopPass = true;
			VHModpackFixPlugin.LogWarning("AdventureBackpacks/AzuAutoStore could not clear an exhausted backpack stack", null);
		}
		int num = (sourceInventory.ContainsItem(sourceItem) ? Math.Max(0, sourceItem.m_stack) : 0);
		int num2 = Math.Max(0, Math.Min(stack, stack - num));
		if (ex != null)
		{
			stopPass = true;
			VHModpackFixPlugin.LogWarning((num2 > 0) ? "AdventureBackpacks/AzuAutoStore stopped after a container accepted part of a stack and then reported an error" : "AdventureBackpacks/AzuAutoStore stopped after a container rejected a backpack transfer with an error", ex);
		}
		return num2;
	}

	private static bool RemoveZeroStack(Inventory inventory, ItemData item)
	{
		inventory.RemoveItem(item);
		if (!inventory.ContainsItem(item))
		{
			return true;
		}
		inventory.GetAllItems().Remove(item);
		_inventoryChanged.Invoke(inventory, null);
		return !inventory.ContainsItem(item);
	}

	private static void ClearActiveStoreScope()
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		if (_activeStoreItem != null)
		{
			_activeStoreItem.m_gridPos = _activeStoreOriginalPosition;
		}
		_activeStoreInventory = null;
		_activeStoreItem = null;
		_activeStoreOriginalPosition = default(Vector2i);
	}

	private static bool BackpackLeftClickPrefix(InventoryGrid __instance, UIInputHandler clickHandler)
	{
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)__instance == (Object)null) && !((Object)(object)clickHandler == (Object)null))
		{
			object? obj = _inventoryGridInventory?.GetValue(__instance);
			Inventory val = (Inventory)((obj is Inventory) ? obj : null);
			if (val != null && IsAdventureBackpackInventory(val) && IsBackpackFavoritingInputHeld())
			{
				Player localPlayer = Player.m_localPlayer;
				InventoryGui instance = InventoryGui.instance;
				GameObject val2 = (GameObject)(((Object)(object)instance == (Object)null) ? null : /*isinst with value type is only supported in some contexts*/);
				if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsTeleporting() || (Object)(object)val2 != (Object)null)
				{
					return true;
				}
				Vector2i val3;
				try
				{
					val3 = (Vector2i)_inventoryGridGetButtonPos.Invoke(__instance, new object[1] { ((Component)clickHandler).gameObject });
				}
				catch (Exception exception)
				{
					LogFavoriteFailure("AdventureBackpacks could not read the clicked backpack slot", exception);
					return true;
				}
				if (val3.x < 0 || val3.y < 0)
				{
					return true;
				}
				ItemData itemAt = val.GetItemAt(val3.x, val3.y);
				if (itemAt?.m_shared == null)
				{
					return true;
				}
				try
				{
					ToggleBackpackStackFavorite(itemAt);
					_inventoryChanged.Invoke(val, null);
					_favoriteBordersDirty = true;
					return false;
				}
				catch (Exception exception2)
				{
					LogFavoriteFailure("AdventureBackpacks could not update the AzuAutoStore favorite item", exception2);
					return true;
				}
			}
		}
		return true;
	}

	private static bool AzuFavoriteCheckPrefix(ItemData item, ref bool __result)
	{
		if (IsBackpackStackFavorite(item))
		{
			__result = true;
			return false;
		}
		if (item != null && item == _activeStoreItem && IsAdventureBackpackInventory(_activeStoreInventory))
		{
			__result = false;
			return false;
		}
		return true;
	}

	private static bool IsBackpackFavoritingInputHeld()
	{
		object obj = _favoritingToggleState?.GetValue(null);
		if (obj is bool && (bool)obj)
		{
			return true;
		}
		if (!IsShortcutHeld(_favoritingModifier1))
		{
			return IsShortcutHeld(_favoritingModifier2);
		}
		return true;
	}

	private static bool IsShortcutHeld(FieldInfo shortcutField)
	{
		//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_0021: 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_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		if (!(shortcutField?.GetValue(null) is ConfigEntry<KeyboardShortcut> val))
		{
			return false;
		}
		KeyboardShortcut value = val.Value;
		if ((int)((KeyboardShortcut)(ref value)).MainKey == 0 || !UnityInput.Current.GetKey(((KeyboardShortcut)(ref value)).MainKey))
		{
			return false;
		}
		foreach (KeyCode modifier in ((KeyboardShortcut)(ref value)).Modifiers)
		{
			if (!UnityInput.Current.GetKey(modifier))
			{
				return false;
			}
		}
		return true;
	}

	private static void ToggleBackpackStackFavorite(ItemData item)
	{
		if (item.m_customData == null)
		{
			item.m_customData = new Dictionary<string, string>();
		}
		if (!item.m_customData.Remove("obelisk.vhmodpackfix.backpackFavorite"))
		{
			item.m_customData["obelisk.vhmodpackfix.backpackFavorite"] = "1";
		}
	}

	private static bool IsBackpackStackFavorite(ItemData item)
	{
		if (item?.m_customData != null)
		{
			return item.m_customData.ContainsKey("obelisk.vhmodpackfix.backpackFavorite");
		}
		return false;
	}

	private static void RenderFavoriteBordersPostfix(InventoryGrid __instance)
	{
		//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_019c: Unknown result type (might be due to invalid IL or missing references)
		if (!_favoritePatched || (Object)(object)__instance == (Object)null)
		{
			return;
		}
		object? obj = _inventoryGridInventory?.GetValue(__instance);
		Inventory val = (Inventory)((obj is Inventory) ? obj : null);
		if (val == null || !IsAdventureBackpackInventory(val) || !(_inventoryGridElements?.GetValue(__instance) is IList list))
		{
			return;
		}
		Image val2 = ((list.Count > 0) ? GetQueuedImage(list[0]) : null);
		if (_lastBorderGrid != __instance || _lastBorderInventory != val || _lastBorderElementCount != list.Count || _lastBorderFirstQueuedImage != val2)
		{
			_lastBorderGrid = __instance;
			_lastBorderInventory = val;
			_lastBorderElementCount = list.Count;
			_lastBorderFirstQueuedImage = val2;
			_favoriteBordersDirty = true;
		}
		if (!_favoriteBordersDirty)
		{
			return;
		}
		try
		{
			Color favoriteBorderColor = GetFavoriteBorderColor();
			for (int i = 0; i < list.Count; i++)
			{
				Image val3 = FindFavoriteBorder(GetQueuedImage(list[i]));
				if ((Object)(object)val3 != (Object)null)
				{
					((Behaviour)val3).enabled = false;
				}
			}
			int width = val.GetWidth();
			List<ItemData> allItems = val.GetAllItems();
			for (int j = 0; j < allItems.Count; j++)
			{
				ItemData val4 = allItems[j];
				if (val4?.m_shared == null || val4.m_stack <= 0 || !IsBackpackStackFavorite(val4))
				{
					continue;
				}
				int num = val4.m_gridPos.y * width + val4.m_gridPos.x;
				if (num >= 0 && num < list.Count)
				{
					Image queuedImage = GetQueuedImage(list[num]);
					Image val5 = FindFavoriteBorder(queuedImage) ?? CreateFavoriteBorder(queuedImage);
					if (!((Object)(object)val5 == (Object)null))
					{
						((Graphic)val5).color = favoriteBorderColor;
						((Behaviour)val5).enabled = true;
					}
				}
			}
			_favoriteBordersDirty = false;
		}
		catch (Exception exception)
		{
			LogFavoriteFailure("AdventureBackpacks could not draw AzuAutoStore favorite borders", exception);
		}
	}

	private static Image GetQueuedImage(object element)
	{
		if (element == null)
		{
			return null;
		}
		if ((object)_elementQueuedImage == null)
		{
			_elementQueuedImage = AccessTools.Field(element.GetType(), "m_queued");
		}
		object? obj = _elementQueuedImage?.GetValue(element);
		return (Image)((obj is Image) ? obj : null);
	}

	private static Image FindFavoriteBorder(Image queued)
	{
		Transform val = (((Object)(object)queued == (Object)null) ? null : ((Component)queued).transform.Find("AzuAutoStoreFavoritingBorder"));
		if (!((Object)(object)val == (Object)null))
		{
			return ((Component)val).GetComponent<Image>();
		}
		return null;
	}

	private static Image CreateFavoriteBorder(Image queued)
	{
		if ((Object)(object)queued == (Object)null || _createFavoriteBorder == null)
		{
			return null;
		}
		object? obj = _createFavoriteBorder.Invoke(null, new object[1] { queued });
		return (Image)((obj is Image) ? obj : null);
	}

	private static Color GetFavoriteBorderColor()
	{
		//IL_005c: 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_0062: Unknown result type (might be due to invalid IL or missing references)
		object obj = _favoriteBorderColor?.GetValue(null);
		object obj2 = obj?.GetType().GetProperty("Value")?.GetValue(obj);
		if (obj2 is Color)
		{
			return (Color)obj2;
		}
		return new Color(1f, 0.8482759f, 0f, 1f);
	}

	private static void LogFavoriteFailure(string message, Exception exception)
	{
		if (!_favoriteFailureLogged)
		{
			_favoriteFailureLogged = true;
			VHModpackFixPlugin.LogWarning(message, Unwrap(exception));
		}
	}

	private static void RemoveInvalidRuntimeStacks(Inventory inventory)
	{
		List<ItemData> list = ((inventory != null) ? inventory.GetAllItems() : null);
		if (list != null && list.RemoveAll((ItemData item) => item == null || item.m_stack <= 0) > 0)
		{
			_inventoryChanged.Invoke(inventory, null);
		}
	}

	private static Vector2i FindFreeSlot(Inventory inventory, int width, int height, int preferredRow)
	{
		//IL_0056: 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_003e: Unknown result type (might be due to invalid IL or missing references)
		if (preferredRow >= 0 && preferredRow < height)
		{
			for (int i = 0; i < width; i++)
			{
				if (inventory.GetItemAt(i, preferredRow) == null)
				{
					return new Vector2i(i, preferredRow);
				}
			}
		}
		for (int j = 0; j < height; j++)
		{
			if (j == preferredRow)
			{
				continue;
			}
			for (int k = 0; k < width; k++)
			{
				if (inventory.GetItemAt(k, j) == null)
				{
					return new Vector2i(k, j);
				}
			}
		}
		return new Vector2i(-1, -1);
	}

	internal static Inventory TryGetEquippedBackpackInventory(Player player)
	{
		try
		{
			return GetEquippedBackpackInventory(player);
		}
		catch (Exception exception)
		{
			if (!_pickupApiFailureLogged)
			{
				_pickupApiFailureLogged = true;
				VHModpackFixPlugin.LogWarning("AdventureBackpacks compatibility could not read the equipped backpack", Unwrap(exception));
			}
			return null;
		}
	}

	private static Inventory GetEquippedBackpackInventory(Player player)
	{
		object[] array = _playerInvokeArguments ?? (_playerInvokeArguments = new object[1]);
		array[0] = player;
		try
		{
			object obj = _getEquippedBackpack.Invoke(null, array);
			return (Inventory)((obj == null) ? null : /*isinst with value type is only supported in some contexts*/);
		}
		finally
		{
			array[0] = null;
		}
	}

	private static bool IsBackpackItem(ItemData item)
	{
		object[] array = _itemInvokeArguments ?? (_itemInvokeArguments = new object[1]);
		array[0] = item;
		try
		{
			object obj = _isBackpackItem?.Invoke(null, array);
			return obj is bool && (bool)obj;
		}
		finally
		{
			array[0] = null;
		}
	}

	private static bool IsAdventureBackpackInventory(Inventory inventory)
	{
		if (inventory == null)
		{
			return false;
		}
		string name = inventory.GetName();
		if (!string.IsNullOrEmpty(name))
		{
			return name.IndexOf("$vapok_mod_level", StringComparison.Ordinal) >= 0;
		}
		return false;
	}

	private static bool IsSupportedContainer(object container)
	{
		string fullName = container.GetType().FullName;
		if (!string.Equals(fullName, "AzuAutoStore.Interfaces.VanillaContainers", StringComparison.Ordinal) && !string.Equals(fullName, "AzuAutoStore.Interfaces.kgDrawer", StringComparison.Ordinal))
		{
			return string.Equals(fullName, "AzuAutoStore.Interfaces.BackpackContainer", StringComparison.Ordinal);
		}
		return true;
	}

	private static bool IsEquippedAdventureBackpackContainer(object container)
	{
		if (container == null || !string.Equals(container.GetType().FullName, "AzuAutoStore.Interfaces.VanillaContainers", StringComparison.Ordinal))
		{
			return false;
		}
		try
		{
			Player localPlayer = Player.m_localPlayer;
			object? obj = _containerGameObject?.GetValue(container);
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			int result;
			if ((Object)(object)localPlayer != (Object)null && (Object)(object)val == (Object)(object)((Component)localPlayer).gameObject)
			{
				object? obj2 = _vanillaContainerGetInventory?.Invoke(container, null);
				Inventory val2 = (Inventory)((obj2 is Inventory) ? obj2 : null);
				if (val2 != null)
				{
					result = (IsAdventureBackpackInventory(val2) ? 1 : 0);
					goto IL_0078;
				}
			}
			result = 0;
			goto IL_0078;
			IL_0078:
			return (byte)result != 0;
		}
		catch
		{
			return false;
		}
	}

	private static bool IsUnsafeSelfTarget(object container, Inventory sourceInventory, Player player)
	{
		try
		{
			if (string.Equals(container.GetType().FullName, "AzuAutoStore.Interfaces.VanillaContainers", StringComparison.Ordinal))
			{
				object? obj = _vanillaContainerGetInventory?.Invoke(container, null);
				Inventory val = (Inventory)((obj is Inventory) ? obj : null);
				if (val != null && val == sourceInventory)
				{
					return true;
				}
			}
			object? obj2 = _containerGameObject?.GetValue(container);
			GameObject val2 = (GameObject)((obj2 is GameObject) ? obj2 : null);
			return (Object)(object)val2 != (Object)null && (Object)(object)player != (Object)null && (Object)(object)val2 == (Object)(object)((Component)player).gameObject;
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("AdventureBackpacks/AzuAutoStore skipped a container whose target could not be verified", Unwrap(exception));
			return true;
		}
	}

	private static float GetPlayerRange()
	{
		object obj = _playerRange?.GetValue(null);
		if (!(obj?.GetType().GetProperty("Value")?.GetValue(obj) is float num) || !(num > 0f))
		{
			return 20f;
		}
		return num;
	}

	private static Type FindLoadedType(string fullName)
	{
		if (string.IsNullOrEmpty(fullName))
		{
			return null;
		}
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		for (int i = 0; i < assemblies.Length; i++)
		{
			try
			{
				Type type = assemblies[i].GetType(fullName, throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			catch
			{
			}
		}
		return null;
	}

	private static Exception Unwrap(Exception exception)
	{
		if (!(exception is TargetInvocationException ex) || exception.InnerException == null)
		{
			return exception;
		}
		return ex.InnerException;
	}

	private static bool ShouldSuppressMessage(MessageType type, string message)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Invalid comparison between Unknown and I4
		if (!_suppressAzuFailureMessage || (int)type != 2 || string.IsNullOrEmpty(message))
		{
			return false;
		}
		if (message.IndexOf("is not in nearby containers", StringComparison.Ordinal) < 0)
		{
			return message.IndexOf("cannot be stored based on configuration settings", StringComparison.Ordinal) >= 0;
		}
		return true;
	}
}
internal static class AdventureBackpacksContainerPanel
{
	private const string ConfigRegistryTypeName = "AdventureBackpacks.Configuration.ConfigRegistry";

	private const string InventoryGuiPatchesTypeName = "AdventureBackpacks.Patches.InventoryGuiPatches";

	private const string PanelName = "VHModpackFix_AdventureBackpackPanel";

	private static ConfigEntry<bool> _enabled;

	private static ConfigEntry<float> _offsetX;

	private static ConfigEntry<float> _offsetY;

	private static FieldInfo _currentContainerField;

	private static FieldInfo _dragItemField;

	private static FieldInfo _openWithInventoryField;

	private static FieldInfo _openWithHoverField;

	private static FieldInfo _backpackIsOpenField;

	private static RectTransform _panel;

	private static InventoryGrid _grid;

	private static TMP_Text _nameText;

	private static TMP_Text _weightText;

	private static InventoryGui _ownerGui;

	private static Inventory _shownInventory;

	private static bool _patched;

	private static bool _failureLogged;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//IL_017f: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Expected O, but got Unknown
		_enabled = ConfigLayout.Bind(config, "AdventureBackpacks", "Show backpack beside opened containers", defaultValue: true, "When AdventureBackpacks' 'Open with Inventory' option is enabled, shows the equipped backpack beside a chest or other opened container.", "AdventureBackpacks UI");
		_offsetX = ConfigLayout.Bind(config, "AdventureBackpacks", "Backpack panel offset X", 650f, "Horizontal backpack-panel offset from the opened container panel. Positive values move it right.", "AdventureBackpacks UI");
		_offsetY = ConfigLayout.Bind(config, "AdventureBackpacks", "Backpack panel offset Y", 0f, "Vertical backpack-panel offset from the opened container panel. Positive values move it up.", "AdventureBackpacks UI");
		if (harmony == null || AccessTools.TypeByName("AdventureBackpacks.Patches.InventoryGuiPatches") == null)
		{
			return;
		}
		ResolveFields();
		if (!(_currentContainerField == null) && !(_dragItemField == null) && !_patched)
		{
			PatchPostfix(harmony, AccessTools.Method(typeof(InventoryGui), "Awake", (Type[])null, (Type[])null), "InventoryGuiAwakePostfix");
			PatchPostfix(harmony, AccessTools.Method(typeof(InventoryGui), "UpdateContainer", (Type[])null, (Type[])null), "UpdateContainerPostfix");
			PatchPostfix(harmony, AccessTools.Method(typeof(InventoryGui), "Hide", (Type[])null, (Type[])null), "HidePostfix");
			PatchPostfix(harmony, AccessTools.Method(typeof(InventoryGui), "CloseContainer", (Type[])null, (Type[])null), "HidePostfix");
			PatchPostfix(harmony, AccessTools.Method(typeof(InventoryGui), "OnDestroy", (Type[])null, (Type[])null), "OnDestroyPostfix");
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryGui), "OnSelectedItem", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(AdventureBackpacksContainerPanel), "OnSelectedItemPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			_patched = true;
		}
	}

	private static void ResolveFields()
	{
		_currentContainerField = AccessTools.Field(typeof(InventoryGui), "m_currentContainer");
		_dragItemField = AccessTools.Field(typeof(InventoryGui), "m_dragItem");
		Type type = AccessTools.TypeByName("AdventureBackpacks.Configuration.ConfigRegistry");
		_openWithInventoryField = ((type == null) ? null : AccessTools.Field(type, "OpenWithInventory"));
		_openWithHoverField = ((type == null) ? null : AccessTools.Field(type, "OpenWithHoverInteract"));
		Type type2 = AccessTools.TypeByName("AdventureBackpacks.Patches.InventoryGuiPatches");
		_backpackIsOpenField = ((type2 == null) ? null : AccessTools.Field(type2, "BackpackIsOpen"));
	}

	private static void PatchPostfix(Harmony harmony, MethodInfo original, string patchName)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Expected O, but got Unknown
		if (original != null)
		{
			harmony.Patch((MethodBase)original, (HarmonyMethod)null, new HarmonyMethod(typeof(AdventureBackpacksContainerPanel), patchName, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}

	private static void InventoryGuiAwakePostfix(InventoryGui __instance)
	{
		try
		{
			DestroyPanel();
			CreatePanel(__instance);
		}
		catch (Exception exception)
		{
			DestroyPanel();
			LogFailure("AdventureBackpacks side panel could not be created", exception);
		}
	}

	private static void UpdateContainerPostfix(InventoryGui __instance, Player player)
	{
		if ((Object)(object)__instance == (Object)null || (Object)(object)player == (Object)null || __instance != _ownerGui)
		{
			HidePanel();
			return;
		}
		try
		{
			RefreshPanel(__instance, player);
		}
		catch (Exception exception)
		{
			HidePanel();
			LogFailure("AdventureBackpacks side panel was disabled after an unexpected UI error", exception);
		}
	}

	private static void RefreshPanel(InventoryGui gui, Player player)
	{
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_panel == (Object)null) && !((Object)(object)_grid == (Object)null))
		{
			ConfigEntry<bool> enabled = _enabled;
			if (enabled != null && enabled.Value && AdventureBackpacksOpenWithInventory() && !AdventureBackpackIsAlreadyOpen())
			{
				object? value = _currentContainerField.GetValue(gui);
				Container val = (Container)((value is Container) ? value : null);
				if ((Object)(object)val == (Object)null || !val.IsOwner())
				{
					HidePanel();
					return;
				}
				Inventory val2 = AdventureBackpacksAutoStoreCompat.TryGetEquippedBackpackInventory(player);
				Inventory inventory = val.GetInventory();
				if (val2 == null || inventory == null || val2 == inventory)
				{
					HidePanel();
					return;
				}
				_panel.anchoredPosition = gui.m_container.anchoredPosition + new Vector2(_offsetX.Value, _offsetY.Value);
				bool num = !((Component)_panel).gameObject.activeSelf || _shownInventory != val2;
				if (!((Component)_panel).gameObject.activeSelf)
				{
					_shownInventory = val2;
					((Component)_panel).gameObject.SetActive(true);
				}
				else if (_shownInventory != val2)
				{
					_shownInventory = val2;
				}
				object? value2 = _dragItemField.GetValue(gui);
				ItemData val3 = (ItemData)((value2 is ItemData) ? value2 : null);
				_grid.UpdateInventory(val2, (Player)null, val3);
				if (num)
				{
					_grid.ResetView();
				}
				if ((Object)(object)_nameText != (Object)null)
				{
					string name = val2.GetName();
					_nameText.text = ((Localization.instance == null) ? name : Localization.instance.Localize(name));
				}
				if ((Object)(object)_weightText != (Object)null)
				{
					_weightText.text = Mathf.CeilToInt(val2.GetTotalWeight()).ToString();
				}
				return;
			}
		}
		HidePanel();
	}

	private static bool AdventureBackpacksOpenWithInventory()
	{
		ConfigEntry<bool> obj = _openWithInventoryField?.GetValue(null) as ConfigEntry<bool>;
		if (obj == null || !obj.Value)
		{
			return false;
		}
		ConfigEntry<bool> obj2 = _openWithHoverField?.GetValue(null) as ConfigEntry<bool>;
		if (obj2 == null)
		{
			return true;
		}
		return !obj2.Value;
	}

	private static bool AdventureBackpackIsAlreadyOpen()
	{
		object obj = _backpackIsOpenField?.GetValue(null);
		if (obj is bool)
		{
			return (bool)obj;
		}
		return false;
	}

	private static void CreatePanel(InventoryGui gui)
	{
		if ((Object)(object)gui == (Object)null || (Object)(object)gui.m_container == (Object)null)
		{
			return;
		}
		GameObject val = Object.Instantiate<GameObject>(((Component)gui.m_container).gameObject, ((Transform)gui.m_container).parent, false);
		((Object)val).name = "VHModpackFix_AdventureBackpackPanel";
		_panel = val.GetComponent<RectTransform>();
		_ownerGui = gui;
		_grid = FindClonedComponent<InventoryGrid>((Transform)(object)gui.m_container, (Transform)(object)_panel, gui.ContainerGrid);
		if ((Object)(object)_panel == (Object)null || (Object)(object)_grid == (Object)null)
		{
			DestroyPanel();
			return;
		}
		_nameText = FindClonedComponent<TMP_Text>((Transform)(object)gui.m_container, (Transform)(object)_panel, gui.m_containerName);
		_weightText = FindClonedComponent<TMP_Text>((Transform)(object)gui.m_container, (Transform)(object)_panel, gui.m_containerWeight);
		Button val2 = FindClonedComponent<Button>((Transform)(object)gui.m_container, (Transform)(object)_panel, gui.m_takeAllButton);
		Button val3 = FindClonedComponent<Button>((Transform)(object)gui.m_container, (Transform)(object)_panel, gui.m_stackAllButton);
		if ((Object)(object)val2 != (Object)null)
		{
			((Component)val2).gameObject.SetActive(false);
		}
		if ((Object)(object)val3 != (Object)null)
		{
			((Component)val3).gameObject.SetActive(false);
		}
		MethodInfo methodInfo = AccessTools.Method(typeof(InventoryGui), "OnSelectedItem", (Type[])null, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(InventoryGui), "OnRightClickItem", (Type[])null, (Type[])null);
		_grid.m_onSelected = ((methodInfo == null) ? null : ((Action<InventoryGrid, ItemData, Vector2i, Modifier>)Delegate.CreateDelegate(typeof(Action<InventoryGrid, ItemData, Vector2i, Modifier>), gui, methodInfo)));
		_grid.m_onRightClick = ((methodInfo2 == null) ? null : ((Action<InventoryGrid, ItemData, Vector2i>)Delegate.CreateDelegate(typeof(Action<InventoryGrid, ItemData, Vector2i>), gui, methodInfo2)));
		_grid.OnMoveToUpperInventoryGrid = null;
		_grid.OnMoveToLowerInventoryGrid = null;
		val.SetActive(false);
	}

	private static bool OnSelectedItemPrefix(InventoryGui __instance, InventoryGrid grid, ItemData item, Modifier mod)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Invalid comparison between Unknown and I4
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)grid == (Object)null || grid != _grid || (int)mod != 2 || item == null)
		{
			return true;
		}
		if (item.m_shared == null || item.m_shared.m_questItem)
		{
			return false;
		}
		Player localPlayer = Player.m_localPlayer;
		object? obj = _currentContainerField?.GetValue(__instance);
		Container val = (Container)((obj is Container) ? obj : null);
		Inventory inventory = grid.GetInventory();
		Inventory val2 = (((Object)(object)val == (Object)null) ? null : val.GetInventory());
		if ((Object)(object)localPlayer == (Object)null || inventory == null || val2 == null || inventory == val2 || !inventory.ContainsItem(item))
		{
			return false;
		}
		try
		{
			val2.MoveItemToThis(inventory, item);
			__instance.m_moveItemEffects.Create(((Component)__instance).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
		}
		catch (Exception exception)
		{
			LogFailure("AdventureBackpacks side-panel quick transfer failed", exception);
		}
		return false;
	}

	private static void HidePostfix(InventoryGui __instance)
	{
		if (__instance == _ownerGui)
		{
			HidePanel();
		}
	}

	private static void OnDestroyPostfix(InventoryGui __instance)
	{
		if (__instance == _ownerGui)
		{
			DestroyPanel();
		}
	}

	private static void HidePanel()
	{
		_shownInventory = null;
		if ((Object)(object)_panel != (Object)null)
		{
			((Component)_panel).gameObject.SetActive(false);
		}
	}

	private static void DestroyPanel()
	{
		if ((Object)(object)_panel != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_panel).gameObject);
		}
		_panel = null;
		_grid = null;
		_nameText = null;
		_weightText = null;
		_ownerGui = null;
		_shownInventory = null;
	}

	private static T FindClonedComponent<T>(Transform originalRoot, Transform cloneRoot, T original) where T : Component
	{
		if ((Object)(object)originalRoot == (Object)null || (Object)(object)cloneRoot == (Object)null || (Object)(object)original == (Object)null)
		{
			return default(T);
		}
		string relativePath = GetRelativePath(originalRoot, ((Component)original).transform);
		if (relativePath == null)
		{
			return default(T);
		}
		Transform val = ((relativePath.Length == 0) ? cloneRoot : cloneRoot.Find(relativePath));
		if (!((Object)(object)val == (Object)null))
		{
			return ((Component)val).GetComponent<T>();
		}
		return default(T);
	}

	private static string GetRelativePath(Transform root, Transform target)
	{
		if (root == target)
		{
			return string.Empty;
		}
		string text = ((Object)target).name;
		Transform parent = target.parent;
		while ((Object)(object)parent != (Object)null && parent != root)
		{
			text = ((Object)parent).name + "/" + text;
			parent = parent.parent;
		}
		if (!((Object)(object)parent == (Object)null))
		{
			return text;
		}
		return null;
	}

	private static Exception Unwrap(Exception exception)
	{
		if (!(exception is TargetInvocationException { InnerException: not null } ex))
		{
			return exception;
		}
		return ex.InnerException;
	}

	private static void LogFailure(string message, Exception exception)
	{
		if (!_failureLogged)
		{
			_failureLogged = true;
			VHModpackFixPlugin.LogWarning(message, Unwrap(exception));
		}
	}
}
internal static class AzuAutoStoreLogFixes
{
	private const string AzuAutoStoreGuid = "Azumatt.AzuAutoStore";

	private const string AzuAutoStoreLogSource = "AzuAutoStore";

	private static ConfigEntry<bool> _enabled;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//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_009a: Expected O, but got Unknown
		_enabled = ConfigLayout.Bind(config, "AzuAutoStore", "Suppress verbose debug logging", defaultValue: true, "Suppresses only Debug-level AzuAutoStore messages such as repeated nearby-item scans. Warnings, errors, information messages, and storage behavior are unchanged.", "AzuAutoStore compatibility");
		if (!Chainloader.PluginInfos.ContainsKey("Azumatt.AzuAutoStore"))
		{
			return;
		}
		MethodInfo methodInfo = AccessTools.Method(typeof(ManualLogSource), "Log", new Type[2]
		{
			typeof(LogLevel),
			typeof(object)
		}, (Type[])null);
		try
		{
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(AzuAutoStoreLogFixes), "FilterAzuAutoStoreDebugPrefix", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			VHModpackFixPlugin.LogInfo("AzuAutoStore Debug-level log filter installed.");
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("Could not install the AzuAutoStore Debug-level log filter", exception);
		}
	}

	private static bool FilterAzuAutoStoreDebugPrefix(ManualLogSource __instance, LogLevel level)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Invalid comparison between Unknown and I4
		ConfigEntry<bool> enabled = _enabled;
		if (enabled != null && enabled.Value && (int)level == 32)
		{
			return !string.Equals((__instance != null) ? __instance.SourceName : null, "AzuAutoStore", StringComparison.Ordinal);
		}
		return true;
	}
}
internal static class AzuCraftyBoxesContainerSafety
{
	private const string VanillaContainerTypeName = "AzuCraftyBoxes.IContainers.VanillaContainer";

	private const string BoxesTypeName = "AzuCraftyBoxes.Util.Functions.Boxes";

	private static readonly string[] RegistryFieldNames = new string[3] { "Containers", "ContainersToAdd", "ContainersToRemove" };

	private static ConfigEntry<bool> _enabled;

	private static FieldInfo _wrappedContainerField;

	private static FieldInfo[] _registryFields;

	private static bool _initialized;

	private static bool _cleanupLogged;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Expected O, but got Unknown
		_enabled = ConfigLayout.Bind(config, "AzuCraftyBoxes", "AzuCraftyBoxes destroyed-container safety", defaultValue: true, "Skips and unregisters cached AzuCraftyBoxes chest wrappers after Unity has destroyed their underlying container.", "Fixes");
		if (_initialized || harmony == null)
		{
			return;
		}
		Type type = AccessTools.TypeByName("AzuCraftyBoxes.IContainers.VanillaContainer");
		Type type2 = AccessTools.TypeByName("AzuCraftyBoxes.Util.Functions.Boxes");
		MethodInfo methodInfo = ((type == null) ? null : AccessTools.Method(type, "GetPrefabName", Type.EmptyTypes, (Type[])null));
		_wrappedContainerField = ((type == null) ? null : AccessTools.Field(type, "<_container>P"));
		if (methodInfo == null || _wrappedContainerField == null || _wrappedContainerField.FieldType != typeof(Container) || type2 == null)
		{
			return;
		}
		_registryFields = new FieldInfo[RegistryFieldNames.Length];
		for (int i = 0; i < RegistryFieldNames.Length; i++)
		{
			FieldInfo fieldInfo = AccessTools.Field(type2, RegistryFieldNames[i]);
			if (fieldInfo == null || fieldInfo.FieldType != typeof(HashSet<Container>))
			{
				_registryFields = null;
				return;
			}
			_registryFields[i] = fieldInfo;
		}
		MethodInfo methodInfo2 = AccessTools.Method(typeof(AzuCraftyBoxesContainerSafety), "GetPrefabNamePrefix", (Type[])null, (Type[])null);
		harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2)
		{
			priority = 800
		}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		_initialized = true;
	}

	private static bool GetPrefabNamePrefix(object __instance, ref string __result)
	{
		ConfigEntry<bool> enabled = _enabled;
		if (enabled == null || !enabled.Value || __instance == null)
		{
			return true;
		}
		object? value = _wrappedContainerField.GetValue(__instance);
		Container val = (Container)((value is Container) ? value : null);
		if ((Object)(object)val != (Object)null)
		{
			return true;
		}
		__result = string.Empty;
		if (val != null)
		{
			RemoveDestroyedContainer(val);
		}
		return false;
	}

	private static void RemoveDestroyedContainer(Container container)
	{
		bool flag = false;
		for (int i = 0; i < _registryFields.Length; i++)
		{
			if (_registryFields[i].GetValue(null) is HashSet<Container> hashSet)
			{
				flag |= hashSet.Remove(container);
			}
		}
		if (flag && !_cleanupLogged)
		{
			_cleanupLogged = true;
			VHModpackFixPlugin.LogInfo("Removed a destroyed container reference from AzuCraftyBoxes' registry");
		}
	}
}
internal static class BalrondArsenalVisualFixes
{
	private static readonly HashSet<int> AffectedChestPrefabHashes = new HashSet<int>
	{
		StringExtensionMethods.GetStableHashCode("ArmorDruidChest_bal"),
		StringExtensionMethods.GetStableHashCode("ArmorFrosteelChest_bal"),
		StringExtensionMethods.GetStableHashCode("ArmorMercChest_bal"),
		StringExtensionMethods.GetStableHashCode("ArmorSerpentLordChest_bal"),
		StringExtensionMethods.GetStableHashCode("ArmorSkaldChest_bal")
	};

	private static readonly HashSet<int> AffectedLegPrefabHashes = new HashSet<int>
	{
		StringExtensionMethods.GetStableHashCode("ArmorFrosteelLegs_bal"),
		StringExtensionMethods.GetStableHashCode("ArmorLoxLegs_bal"),
		StringExtensionMethods.GetStableHashCode("ArmorSerpentLordLegs_bal")
	};

	private static readonly FieldRef<VisEquipment, List<GameObject>> ChestItemInstances = AccessTools.FieldRefAccess<VisEquipment, List<GameObject>>("m_chestItemInstances");

	private static readonly FieldRef<VisEquipment, List<GameObject>> LegItemInstances = AccessTools.FieldRefAccess<VisEquipment, List<GameObject>>("m_legItemInstances");

	private static ConfigEntry<bool> _enabled;

	internal static void Bind(ConfigFile config)
	{
		_enabled = ConfigLayout.Bind(config, "Balrond Arsenal", "Enable Balrond Arsenal fixes", defaultValue: true, "Repair stretched Balrond Arsenal chest and leg armor without hiding or replacing any visual parts.", "Global Fix Switches");
	}

	internal static void RestoreChestBones(VisEquipment equipment, int itemHash, bool changed)
	{
		if (ShouldRepair(equipment, itemHash, changed, AffectedChestPrefabHashes))
		{
			RestoreDamagedBindings(equipment, ChestItemInstances.Invoke(equipment));
		}
	}

	internal static void RestoreLegBones(VisEquipment equipment, int itemHash, bool changed)
	{
		if (ShouldRepair(equipment, itemHash, changed, AffectedLegPrefabHashes))
		{
			RestoreDamagedBindings(equipment, LegItemInstances.Invoke(equipment));
		}
	}

	private static bool ShouldRepair(VisEquipment equipment, int itemHash, bool changed, HashSet<int> affectedPrefabHashes)
	{
		if ((_enabled?.Value ?? false) && changed && (Object)(object)equipment != (Object)null)
		{
			return affectedPrefabHashes.Contains(itemHash);
		}
		return false;
	}

	private static void RestoreDamagedBindings(VisEquipment equipment, List<GameObject> roots)
	{
		SkinnedMeshRenderer bodyModel = equipment.m_bodyModel;
		Transform[] array = ((bodyModel != null) ? bodyModel.bones : null);
		if ((Object)(object)bodyModel == (Object)null || (Object)(object)bodyModel.rootBone == (Object)null || array == null || array.Length == 0 || ContainsNull(array) || roots == null)
		{
			return;
		}
		for (int i = 0; i < roots.Count; i++)
		{
			GameObject val = roots[i];
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			SkinnedMeshRenderer[] componentsInChildren = val.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val2 in componentsInChildren)
			{
				Mesh val3 = ((val2 != null) ? val2.sharedMesh : null);
				Transform[] array2 = ((val2 != null) ? val2.bones : null);
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null) && array2 != null && array2.Length == array.Length && val3.bindposeCount == array.Length && RepairNullBones(array2, array))
				{
					val2.rootBone = bodyModel.rootBone;
					val2.bones = array2;
				}
			}
		}
	}

	private static bool RepairNullBones(Transform[] rendererBones, Transform[] bodyBones)
	{
		bool result = false;
		for (int i = 0; i < rendererBones.Length; i++)
		{
			if (!((Object)(object)rendererBones[i] != (Object)null))
			{
				rendererBones[i] = bodyBones[i];
				result = true;
			}
		}
		return result;
	}

	private static bool ContainsNull(Transform[] transforms)
	{
		for (int i = 0; i < transforms.Length; i++)
		{
			if ((Object)(object)transforms[i] == (Object)null)
			{
				return true;
			}
		}
		return false;
	}
}
[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped", new Type[] { typeof(int) })]
[HarmonyAfter(new string[] { "vapok.mods.adventurebackpacks", "com.jotunn.jotunn" })]
internal static class BalrondArsenalVisEquipmentSetChestPatch
{
	[HarmonyPriority(0)]
	private static void Postfix(VisEquipment __instance, int hash, bool __result)
	{
		BalrondArsenalVisualFixes.RestoreChestBones(__instance, hash, __result);
	}
}
[HarmonyPatch(typeof(VisEquipment), "SetLegEquipped", new Type[] { typeof(int) })]
[HarmonyAfter(new string[] { "vapok.mods.adventurebackpacks", "com.jotunn.jotunn" })]
internal static class BalrondArsenalVisEquipmentSetLegPatch
{
	[HarmonyPriority(0)]
	private static void Postfix(VisEquipment __instance, int hash, bool __result)
	{
		BalrondArsenalVisualFixes.RestoreLegBones(__instance, hash, __result);
	}
}
internal static class BossAddNetworkVfxFixes
{
	private const string BossAddGuid = "bossadd";

	private static readonly MethodInfo UnityDestroyDelayed = AccessTools.Method(typeof(Object), "Destroy", new Type[2]
	{
		typeof(Object),
		typeof(float)
	}, (Type[])null);

	private static readonly MethodInfo SafeDestroyDelayed = AccessTools.Method(typeof(BossAddNetworkVfxFixes), "DestroyTemporaryVfxSafely", new Type[2]
	{
		typeof(Object),
		typeof(float)
	}, (Type[])null);

	private static readonly MethodInfo UnityDestroyImmediate = AccessTools.Method(typeof(Object), "Destroy", new Type[1] { typeof(Object) }, (Type[])null);

	private static readonly MethodInfo SafeDestroyImmediate = AccessTools.Method(typeof(BossAddNetworkVfxFixes), "DestroyTemporaryVfxSafely", new Type[1] { typeof(Object) }, (Type[])null);

	private static ConfigEntry<bool> _enabled;

	private static ConfigEntry<bool> _safeMiniBonemassProjectiles;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		_enabled = ConfigLayout.Bind(config, "BossAdd", "Safe temporary VFX cleanup", defaultValue: true, "Prevents BossAdd temporary boss effects from leaving destroyed network objects in Valheim's zone registry. This removes the repeating ZNetScene.RemoveObjects error that can appear after teleporting or unloading a zone. The switch affects future BossAdd cleanup immediately. Fully restart Valheim once after installing or updating, and restart if the repeating error began before this version was loaded.", "BossAdd compatibility");
		_safeMiniBonemassProjectiles = ConfigLayout.Bind(config, "BossAdd", "Safe MiniBonemass projectile blocking", defaultValue: true, "Replaces BossAdd's unsafe Projectile.Setup cancellation for MiniBonemass. The projectile is initialized normally, then removed through Valheim's network scene before it can update or hit anything. This preserves BossAdd's intended projectile block without leaving SpawnAbility with a null owner. Restart Valheim after changing this setting.", "BossAdd compatibility");
		if (Chainloader.PluginInfos.ContainsKey("bossadd"))
		{
			int num = 0;
			num += PatchMethod(harmony, "bossadd.Patches.BossSummonHelper", "SpecialSummon", "ReplaceDelayedVfxDestroyTranspiler");
			num += PatchMethod(harmony, "bossadd.Patches.QueenBreathSummonPatch", "TrySummon", "ReplaceDelayedVfxDestroyTranspiler");
			num += PatchMethod(harmony, "bossadd.Patches.QueenBroodSummonHelper", "DoSummon", "ReplaceDelayedVfxDestroyTranspiler");
			num += PatchMethod(harmony, "bossadd.Patches.YagluthSkeletonSummonPatch", "DoSummon", "ReplaceDelayedVfxDestroyTranspiler");
			num += PatchMethod(harmony, "bossadd.Patches.YagluthDeathZoneHandler", "OnAttackTrigger", "ReplaceDelayedVfxDestroyTranspiler");
			num += PatchMethod(harmony, "bossadd.Patches.YagluthMeteorFireHandler", "Tick", "ReplaceImmediateVfxDestroyTranspiler");
			num += PatchMethod(harmony, "bossadd.Patches.QueenPoisonZoneHandler", "Tick", "ReplaceImmediateVfxDestroyTranspiler");
			num += PatchMethod(harmony, "bossadd.Patches.QueenPoisonZoneHandler", "SpawnZone", "ReplaceImmediateVfxDestroyTranspiler");
			num += PatchMethod(harmony, "bossadd.Patches.QueenPoisonZoneHandler", "OnQueenDeath", "ReplaceImmediateVfxDestroyTranspiler");
			VHModpackFixPlugin.LogInfo($"BossAdd network-VFX compatibility installed on {num}/9 cleanup paths.");
			if (_safeMiniBonemassProjectiles.Value)
			{
				InstallMiniBonemassProjectileRepair(harmony);
			}
		}
	}

	private static void InstallMiniBonemassProjectileRepair(Harmony harmony)
	{
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Expected O, but got Unknown
		Type type = AccessTools.TypeByName("bossadd.Patches.MiniBonemassProjectileBlockPatch");
		MethodInfo unsafePrefix = ((type == null) ? null : AccessTools.Method(type, "Prefix", new Type[1] { typeof(Character) }, (Type[])null));
		MethodInfo methodInfo = AccessTools.Method(typeof(Projectile), "Setup", new Type[6]
		{
			typeof(Character),
			typeof(Vector3),
			typeof(float),
			typeof(HitData),
			typeof(ItemData),
			typeof(ItemData)
		}, (Type[])null);
		if (unsafePrefix == null || methodInfo == null)
		{
			VHModpackFixPlugin.LogWarning("BossAdd MiniBonemass projectile targets were not found; the safety repair was skipped.", null);
			return;
		}
		Patches patchInfo = Harmony.GetPatchInfo((MethodBase)methodInfo);
		if (patchInfo == null || !patchInfo.Prefixes.Any((Patch patch) => patch.PatchMethod == unsafePrefix))
		{
			VHModpackFixPlugin.LogWarning("BossAdd MiniBonemass Projectile.Setup blocker was not installed; no patch was removed or replaced.", null);
			return;
		}
		try
		{
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(BossAddNetworkVfxFixes), "RemoveBlockedMiniBonemassProjectilePostfix", (Type[])null, (Type[])null))
			{
				priority = 0
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Unpatch((MethodBase)methodInfo, unsafePrefix);
			VHModpackFixPlugin.LogInfo("BossAdd MiniBonemass projectile blocker replaced with initialize-then-network-destroy handling.");
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("Could not replace the BossAdd MiniBonemass projectile blocker", exception);
		}
	}

	private static void RemoveBlockedMiniBonemassProjectilePostfix(Projectile __instance, Character owner)
	{
		if (!Object.op_Implicit((Object)(object)__instance) || !IsMiniBonemass(owner))
		{
			return;
		}
		GameObject gameObject = ((Component)__instance).gameObject;
		ZNetView component = gameObject.GetComponent<ZNetView>();
		ZNetScene instance = ZNetScene.instance;
		if (Object.op_Implicit((Object)(object)component) && component.IsValid())
		{
			if (Object.op_Implicit((Object)(object)instance) && component.IsOwner())
			{
				((Behaviour)__instance).enabled = false;
				instance.Destroy(gameObject);
			}
		}
		else
		{
			((Behaviour)__instance).enabled = false;
			Object.Destroy((Object)(object)gameObject);
		}
	}

	private static bool IsMiniBonemass(Character owner)
	{
		if (!Object.op_Implicit((Object)(object)owner))
		{
			return false;
		}
		return Utils.GetPrefabName(((Component)owner).gameObject)?.StartsWith("MiniBonemass_", StringComparison.Ordinal) ?? false;
	}

	private static int PatchMethod(Harmony harmony, string typeName, string methodName, string transpilerName)
	{
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Expected O, but got Unknown
		Type type = AccessTools.TypeByName(typeName);
		if (type == null)
		{
			VHModpackFixPlugin.LogWarning("BossAdd compatibility target type '" + typeName + "' was not found; this path was skipped.", null);
			return 0;
		}
		MethodInfo[] array = (from method in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
			where method.Name == methodName
			select method).ToArray();
		if (array.Length != 1)
		{
			VHModpackFixPlugin.LogWarning($"BossAdd compatibility expected one '{typeName}.{methodName}' method but found {array.Length}; this path was skipped.", null);
			return 0;
		}
		MethodInfo methodInfo = AccessTools.Method(typeof(BossAddNetworkVfxFixes), transpilerName, (Type[])null, (Type[])null);
		try
		{
			harmony.Patch((MethodBase)array[0], (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(methodInfo)
			{
				priority = 0
			}, (HarmonyMethod)null, (HarmonyMethod)null);
			return 1;
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("Could not install BossAdd compatibility for " + typeName + "." + methodName, exception);
			return 0;
		}
	}

	private static IEnumerable<CodeInstruction> ReplaceDelayedVfxDestroyTranspiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod)
	{
		List<CodeInstruction> list = instructions.ToList();
		List<int> list2 = new List<int>();
		for (int i = 0; i < list.Count; i++)
		{
			if (CodeInstructionExtensions.Calls(list[i], UnityDestroyDelayed))
			{
				list2.Add(i);
			}
		}
		if (list2.Count != 1)
		{
			VHModpackFixPlugin.LogWarning($"BossAdd compatibility found {list2.Count} delayed VFX cleanup calls in {Describe(__originalMethod)}; expected one, so its IL was left unchanged.", null);
			return list;
		}
		list[list2[0]].opcode = OpCodes.Call;
		list[list2[0]].operand = SafeDestroyDelayed;
		return list;
	}

	private static IEnumerable<CodeInstruction> ReplaceImmediateVfxDestroyTranspiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod)
	{
		List<CodeInstruction> list = instructions.ToList();
		List<int> list2 = new List<int>();
		for (int i = 0; i < list.Count; i++)
		{
			if (CodeInstructionExtensions.Calls(list[i], UnityDestroyImmediate))
			{
				list2.Add(i);
			}
		}
		if (list2.Count != 1)
		{
			VHModpackFixPlugin.LogWarning($"BossAdd compatibility found {list2.Count} immediate VFX cleanup calls in {Describe(__originalMethod)}; expected one, so its IL was left unchanged.", null);
			return list;
		}
		list[list2[0]].opcode = OpCodes.Call;
		list[list2[0]].operand = SafeDestroyImmediate;
		return list;
	}

	private static void DestroyTemporaryVfxSafely(Object value, float delay)
	{
		if (IsEnabled())
		{
			GameObject val = (GameObject)(object)((value is GameObject) ? value : null);
			if (val != null && HasLiveNetworkView(val))
			{
				BossAddSafeVfxCleanup bossAddSafeVfxCleanup = val.GetComponent<BossAddSafeVfxCleanup>();
				if (!Object.op_Implicit((Object)(object)bossAddSafeVfxCleanup))
				{
					bossAddSafeVfxCleanup = val.AddComponent<BossAddSafeVfxCleanup>();
				}
				bossAddSafeVfxCleanup.Schedule(delay);
				return;
			}
		}
		Object.Destroy(value, delay);
	}

	private static void DestroyTemporaryVfxSafely(Object value)
	{
		if (IsEnabled())
		{
			GameObject val = (GameObject)(object)((value is GameObject) ? value : null);
			if (val != null && HasLiveNetworkView(val))
			{
				DestroyNetworkedHierarchy(val);
				return;
			}
		}
		Object.Destroy(value);
	}

	private static bool HasLiveNetworkView(GameObject root)
	{
		ZNetView[] componentsInChildren = root.GetComponentsInChildren<ZNetView>(true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			if (Object.op_Implicit((Object)(object)componentsInChildren[i]) && componentsInChildren[i].GetZDO() != null)
			{
				return true;
			}
		}
		return false;
	}

	internal static void DestroyNetworkedHierarchy(GameObject root)
	{
		if (!Object.op_Implicit((Object)(object)root))
		{
			return;
		}
		ZNetScene instance = ZNetScene.instance;
		ZNetView[] componentsInChildren = root.GetComponentsInChildren<ZNetView>(true);
		bool flag = false;
		foreach (ZNetView val in componentsInChildren)
		{
			if (Object.op_Implicit((Object)(object)val) && val.GetZDO() != null)
			{
				flag = true;
				break;
			}
		}
		if (!flag)
		{
			Object.Destroy((Object)(object)root);
		}
		else
		{
			if (!Object.op_Implicit((Object)(object)instance) || ZDOMan.instance == null)
			{
				return;
			}
			foreach (ZNetView val2 in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)val2) && val2.GetZDO() != null)
				{
					if (!val2.IsOwner())
					{
						val2.ClaimOwnership();
					}
					if (!val2.IsOwner())
					{
						return;
					}
				}
			}
			for (int num = componentsInChildren.Length - 1; num >= 0; num--)
			{
				ZNetView val3 = componentsInChildren[num];
				if (Object.op_Implicit((Object)(object)val3) && val3.GetZDO() != null)
				{
					instance.Destroy(((Component)val3).gameObject);
				}
			}
			if (Object.op_Implicit((Object)(object)root))
			{
				Object.Destroy((Object)(object)root);
			}
		}
	}

	private static bool IsEnabled()
	{
		return _enabled?.Value ?? false;
	}

	private static string Describe(MethodBase method)
	{
		if (!(method == null))
		{
			return method.DeclaringType?.FullName + "." + method.Name;
		}
		return "an unknown method";
	}
}
public sealed class BossAddSafeVfxCleanup : MonoBehaviour
{
	private bool _scheduled;

	internal void Schedule(float delay)
	{
		if (_scheduled)
		{
			((MonoBehaviour)this).CancelInvoke("DestroySafely");
		}
		_scheduled = true;
		((MonoBehaviour)this).Invoke("DestroySafely", Mathf.Max(0f, delay));
	}

	private void DestroySafely()
	{
		BossAddNetworkVfxFixes.DestroyNetworkedHierarchy(((Component)this).gameObject);
	}
}
internal static class BowFixes
{
	internal struct FireState
	{
		internal bool Applied;

		internal float Velocity;

		internal float Accuracy;
	}

	[HarmonyPatch(typeof(Attack), "FireProjectileBurst")]
	[HarmonyBefore(new string[] { "randyknapp.mods.epicloot" })]
	private static class FireProjectileBurstPatch
	{
		[HarmonyPriority(800)]
		private static void Prefix(Attack __instance, out FireState __state)
		{
			__state = PrepareShot(__instance);
		}

		[HarmonyPriority(0)]
		private static Exception Finalizer(Exception __exception, Attack __instance, FireState __state)
		{
			RestoreShot(__instance, __state);
			return __exception;
		}
	}

	[HarmonyPatch(typeof(Attack), "GetProjectileSpawnPoint")]
	private static class ProjectileSpawnPointPatch
	{
		private static void Postfix(Attack __instance, ref Vector3 spawnPoint, ref Vector3 aimDir)
		{
			AdjustAim(__instance, ref spawnPoint, ref aimDir);
		}
	}

	[HarmonyPatch]
	private static class ProjectileSetupPatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(Projectile), "Setup", new Type[6]
			{
				typeof(Character),
				typeof(Vector3),
				typeof(float),
				typeof(HitData),
				typeof(ItemData),
				typeof(ItemData)
			}, (Type[])null);
		}

		private static void Prefix(Projectile __instance, Character owner, ItemData item)
		{
			AdjustProjectile(__instance, owner, item);
		}
	}

	[HarmonyPatch(typeof(Hud), "UpdateCrosshair")]
	private static class HudCrosshairPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Hud __instance, Player player, float bowDrawPercentage)
		{
			UpdateAim(__instance, player, bowDrawPercentage);
		}
	}

	[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]
	[HarmonyAfter(new string[] { "Azumatt.FirstPersonMode" })]
	private static class GameCameraPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(GameCamera __instance)
		{
			ApplyZoom(__instance);
		}
	}

	[HarmonyPatch(typeof(Player), "SetControls")]
	private static class PlayerControlsPatch
	{
		[HarmonyPriority(0)]
		private static void Prefix(Player __instance, bool attackHold, bool secondaryAttackHold, ref bool blockHold)
		{
			ApplyDrawCancel(__instance, attackHold, secondaryAttackHold, ref blockHold);
		}
	}

	private const string EpicLootGuid = "randyknapp.mods.epicloot";

	private const string FirstPersonModeGuid = "Azumatt.FirstPersonMode";

	private static readonly FieldRef<Attack, Humanoid> AttackCharacter = AccessTools.FieldRefAccess<Attack, Humanoid>("m_character");

	private static readonly FieldRef<Attack, ItemData> AttackWeapon = AccessTools.FieldRefAccess<Attack, ItemData>("m_weapon");

	private static readonly FieldRef<Humanoid, ItemData> AmmoItem = AccessTools.FieldRefAccess<Humanoid, ItemData>("m_ammoItem");

	private static readonly FieldRef<Humanoid, VisEquipment> VisEquipment = AccessTools.FieldRefAccess<Humanoid, VisEquipment>("m_visEquipment");

	private static readonly FieldRef<GameCamera, Camera> MainCamera = AccessTools.FieldRefAccess<GameCamera, Camera>("m_camera");

	private static readonly FieldRef<GameCamera, Camera> SkyCamera = AccessTools.FieldRefAccess<GameCamera, Camera>("m_skyCamera");

	private static readonly MethodInfo GetAttackOriginMethod = AccessTools.Method(typeof(Attack), "GetAttackOrigin", (Type[])null, (Type[])null);

	private static ConfigEntry<bool> _enabled;

	private static ConfigEntry<bool> _arrowPhysicsEnabled;

	private static ConfigEntry<float> _arrowVelocity;

	private static ConfigEntry<float> _arrowGravity;

	private static ConfigEntry<float> _arrowAccuracy;

	private static ConfigEntry<Vector3> _arrowAimDirection;

	private static ConfigEntry<bool> _leftHandProjectileOrigin;

	private static ConfigEntry<bool> _bowAimEnabled;

	private static ConfigEntry<bool> _automaticBowZoom;

	private static ConfigEntry<KeyboardShortcut> _bowZoomHotkey;

	private static ConfigEntry<KeyboardShortcut> _bowDrawCancelHotkey;

	private static ConfigEntry<float> _bowZoomFactor;

	private static ConfigEntry<float> _bowZoomConstantTime;

	private static ConfigEntry<bool> _crosshairVisible;

	private static ConfigEntry<bool> _bowCrosshairVisible;

	private static ConfigEntry<bool> _movementReductionEnabled;

	private static Player _trackedPlayer;

	private static bool _drawing;

	private static bool _forcedWalk;

	private static bool _manualAimLatched;

	private static ItemData _manualAimWeapon;

	private static float _zoomBlend;

	private static float _zoomInDuration = 0.3f;

	private static bool _wantedZoomLastFrame;

	private static ItemData _zoomDurationWeapon;

	private static KeyCode _zoomMainKey;

	private static KeyCode[] _zoomModifiers = Array.Empty<KeyCode>();

	private static KeyCode _cancelMainKey;

	private static KeyCode[] _cancelModifiers = Array.Empty<KeyCode>();

	private static bool _shortcutEventsBound;

	private static bool PhysicsEnabled
	{
		get
		{
			ConfigEntry<bool> enabled = _enabled;
			if (enabled != null && enabled.Value)
			{
				return _arrowPhysicsEnabled?.Value ?? false;
			}
			return false;
		}
	}

	private static bool AimEnabled
	{
		get
		{
			ConfigEntry<bool> enabled = _enabled;
			if (enabled != null && enabled.Value)
			{
				return _bowAimEnabled?.Value ?? false;
			}
			return false;
		}
	}

	internal static void Bind(ConfigFile config)
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_021a: Unknown result type (might be due to invalid IL or missing references)
		UnbindShortcutEvents();
		_bowAimEnabled = ConfigLayout.Bind(config, "Bow - Aim", "Enable bow aim", defaultValue: true, "Enable crosshair options, bow zoom, draw cancel, and draw movement handling.", "Bow Aim");
		_automaticBowZoom = ConfigLayout.Bind(config, "Bow - Aim", "Automatic bow zoom", defaultValue: false, "Zoom automatically while drawing a bow.", "Bow Aim");
		_bowZoomHotkey = ConfigLayout.Bind<KeyboardShortcut>(config, "Bow - Aim", "Bow zoom hotkey", new KeyboardShortcut((KeyCode)324, Array.Empty<KeyCode>()), "Press while drawing to latch aim; zoom remains until this shortcut is released or the weapon changes.", "Bow Aim");
		_bowDrawCancelHotkey = ConfigLayout.Bind<KeyboardShortcut>(config, "Bow - Aim", "Bow draw cancel hotkey", new KeyboardShortcut((KeyCode)101, Array.Empty<KeyCode>()), "Press while holding a bow attack to cancel it through the normal block input.", "Bow Aim");
		_bowZoomFactor = ConfigLayout.Bind(config, "Bow - Aim", "Bow zoom factor", 2f, "Maximum bow zoom factor.", "Bow Aim");
		_bowZoomConstantTime = ConfigLayout.Bind(config, "Bow - Aim", "Bow zoom constant time", -1f, "Set above 0 for a constant zoom-in time; -1 scales it with bow skill.", "Bow Aim");
		_crosshairVisible = ConfigLayout.Bind(config, "Bow - Aim", "Show crosshair", defaultValue: true, "Show the regular crosshair.", "Bow Aim");
		_bowCrosshairVisible = ConfigLayout.Bind(config, "Bow - Aim", "Show bow crosshair", defaultValue: true, "Show the bow draw crosshair.", "Bow Aim");
		_movementReductionEnabled = ConfigLayout.Bind(config, "Bow - Aim", "Enable bow draw movement speed reduction", defaultValue: true, "Force walking only while this mod detects a drawn bow.", "Bow Aim");
		_enabled = ConfigLayout.Bind(config, "Bow - General", "Enable BetterArchery-style bow fixes", defaultValue: true, "Master switch for the lightweight bow physics and aiming fixes.", "Global Fix Switches");
		_arrowPhysicsEnabled = ConfigLayout.Bind(config, "Bow - Physics", "Enable arrow physics", defaultValue: true, "Enable bow projectile speed, gravity, accuracy, and aim-direction changes.", "Arrow Physics");
		_arrowVelocity = ConfigLayout.Bind(config, "Bow - Physics", "Arrow velocity", 70f, "Base projectile velocity used for player bows. Epic Loot modifiers are applied on top.", "Arrow Physics");
		_arrowGravity = ConfigLayout.Bind(config, "Bow - Physics", "Arrow gravity", 15f, "Projectile gravity used for local-player bow projectiles.", "Arrow Physics");
		_arrowAccuracy = ConfigLayout.Bind(config, "Bow - Physics", "Arrow accuracy", 0f, "Projectile spread override. Set below 0 to keep the weapon value.", "Arrow Physics");
		_arrowAimDirection = ConfigLayout.Bind<Vector3>(config, "Bow - Physics", "Aim direction offset", new Vector3(0f, 0.05f, 0f), "Small aim-direction offset applied to player bow shots.", "Arrow Physics");
		_leftHandProjectileOrigin = ConfigLayout.Bind(config, "Bow - Physics", "Use left hand projectile origin", defaultValue: true, "Spawn bow projectiles at the left hand, matching the previous VHModpackFix behavior.", "Arrow Physics");
		BindShortcutEvents();
	}

	internal static FireState PrepareShot(Attack attack)
	{
		FireState result = default(FireState);
		if (!PhysicsEnabled || !IsLocalBowAttack(attack) || AmmoItem.Invoke(AttackCharacter.Invoke(attack)) == null)
		{
			return result;
		}
		result.Applied = true;
		result.Velocity = attack.m_projectileVel;
		result.Accuracy = attack.m_projectileAccuracy;
		attack.m_projectileVel = Mathf.Max(0.1f, _arrowVelocity.Value);
		if (_arrowAccuracy.Value >= 0f)
		{
			attack.m_projectileAccuracy = _arrowAccuracy.Value;
		}
		return result;
	}

	internal static void RestoreShot(Attack attack, FireState state)
	{
		if (state.Applied && attack != null)
		{
			attack.m_projectileVel = state.Velocity;
			attack.m_projectileAccuracy = state.Accuracy;
		}
	}

	internal static void AdjustAim(Attack attack, ref Vector3 spawnPoint, ref Vector3 aimDirection)
	{
		//IL_013e: 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_014d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: 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_0112: 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)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0064: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: 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)
		if (!PhysicsEnabled || !IsLocalBowAttack(attack))
		{
			return;
		}
		Humanoid val = AttackCharacter.Invoke(attack);
		if (_leftHandProjectileOrigin.Value)
		{
			Transform val2 = VisEquipment.Invoke(val)?.m_leftHand;
			if ((Object)(object)val2 != (Object)null)
			{
				spawnPoint = val2.position;
				aimDirection = val.GetAimDir(spawnPoint);
			}
		}
		if (aimDirection.y <= -0.8f)
		{
			object? obj = GetAttackOriginMethod?.Invoke(attack, Array.Empty<object>());
			Transform val3 = (Transform)((obj is Transform) ? obj : null);
			if ((Object)(object)val3 != (Object)null)
			{
				Transform transform = ((Component)val).transform;
				spawnPoint = val3.position + transform.up * attack.m_attackHeight + transform.forward * 0.7f + transform.right * attack.m_attackOffset;
				aimDirection = val.GetAimDir(spawnPoint);
			}
		}
		if (attack.m_useCharacterFacing)
		{
			Vector3 forward = Vector3.forward;
			if (attack.m_useCharacterFacingYAim)
			{
				forward.y = aimDirection.y;
			}
			aimDirection = ((Component)val).transform.TransformDirection(forward);
		}
		aimDirection += _arrowAimDirection.Value;
		if (((Vector3)(ref aimDirection)).sqrMagnitude > 0.0001f)
		{
			((Vector3)(ref aimDirection)).Normalize();
		}
	}

	internal static void AdjustProjectile(Projectile projectile, Character owner, ItemData weapon)
	{
		if (PhysicsEnabled && (Object)(object)projectile != (Object)null && (Object)(object)owner == (Object)(object)Player.m_localPlayer && IsBow(weapon))
		{
			projectile.m_gravity = Mathf.Max(0f, _arrowGravity.Value);
		}
	}

	internal static void UpdateAim(Hud hud, Player player, float drawPercentage)
	{
		if ((Object)(object)player != (Object)(object)_trackedPlayer)
		{
			StopPlayerEffects();
			_zoomBlend = 0f;
			ResetZoomTiming();
			_trackedPlayer = player;
		}
		if (!AimEnabled || (Object)(object)hud == (Object)null || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
		{
			StopPlayerEffects();
			_zoomBlend = 0f;
			ResetZoomTiming();
			return;
		}
		if ((Object)(object)hud.m_crosshair != (Object)null)
		{
			((Behaviour)hud.m_crosshair).enabled = _crosshairVisible.Value;
		}
		if ((Object)(object)hud.m_crosshairBow != (Object)null)
		{
			((Behaviour)hud.m_crosshairBow).enabled = _bowCrosshairVisible.Value;
		}
		if (!(drawPercentage <= 0.01f) || _drawing || _manualAimLatched || !(_zoomBlend <= 0f))
		{
			ItemData currentWeapon = ((Humanoid)player).GetCurrentWeapon();
			bool drawing = _drawing;
			_drawing = drawPercentage > 0.1f && IsBow(currentWeapon);
			UpdateForcedWalk(player, drawing);
			bool flag = WantsZoom(currentWeapon, drawPercentage);
			if (flag && (!_wantedZoomLastFrame || currentWeapon != _zoomDurationWeapon))
			{
				_zoomInDuration = GetZoomInTime(player, currentWeapon);
				_zoomDurationWeapon = currentWeapon;
			}
			_wantedZoomLastFrame = flag;
			float num = (flag ? _zoomInDuration : 0.3f);
			float num2 = Time.deltaTime / Mathf.Max(0.05f, num);
			_zoomBlend = Mathf.MoveTowards(_zoomBlend, flag ? 1f : 0f, num2);
		}
	}

	internal static void ApplyZoom(GameCamera camera)
	{
		Camera val = (((Object)(object)camera == (Object)null) ? null : MainCamera.Invoke(camera));
		if (AimEnabled && !((Object)(object)val == (Object)null) && !(_zoomBlend <= 0f))
		{
			float fieldOfView = val.fieldOfView;
			float num = fieldOfView / Mathf.Max(1f, _bowZoomFactor.Value);
			float fieldOfView2 = (val.fieldOfView = Mathf.Lerp(fieldOfView, num, Mathf.SmoothStep(0f, 1f, _zoomBlend)));
			Camera val2 = SkyCamera.Invoke(camera);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.fieldOfView = fieldOfView2;
			}
		}
	}

	internal static void ApplyDrawCancel(Player player, bool attackHold, bool secondaryAttackHold, ref bool blockHold)
	{
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		if (!AimEnabled || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
		{
			return;
		}
		ItemData currentWeapon = ((Humanoid)player).GetCurrentWeapon();
		bool flag = IsSecondaryBowDrawHeld(currentWeapon, secondaryAttackHold);
		bool flag2 = attackHold || flag || _drawing;
		if (!flag2 && !_manualAimLatched)
		{
			return;
		}
		UpdateManualAimLatch(currentWeapon, flag2);
		if (IsBow(currentWeapon))
		{
			if (flag2)
			{
				blockHold = IsShortcutHeld(_cancelMainKey, _cancelModifiers);
			}
			else if (_manualAimLatched)
			{
				blockHold = false;
			}
		}
	}

	internal static void Reset()
	{
		UnbindShortcutEvents();
		StopPlayerEffects();
		_trackedPlayer = null;
		_zoomBlend = 0f;
		ResetZoomTiming();
	}

	private static bool WantsZoom(ItemData weapon, float drawPercentage)
	{
		if (!IsBow(weapon))
		{
			ClearManualAimLatch();
			return false;
		}
		if (_automaticBowZoom.Value)
		{
			ClearManualAimLatch();
			return drawPercentage > 0.01f;
		}
		UpdateManualAimLatch(weapon, _drawing);
		return _manualAimLatched;
	}

	private static void UpdateManualAimLatch(ItemData weapon, bool drawingOrAttackHeld)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		if (!IsBow(weapon) || _automaticBowZoom.Value)
		{
			ClearManualAimLatch();
		}
		else if (_manualAimLatched && weapon != _manualAimWeapon)
		{
			ClearManualAimLatch();
		}
		else if (!IsShortcutHeld(_zoomMainKey, _zoomModifiers))
		{
			ClearManualAimLatch();
		}
		else if (!_manualAimLatched && drawingOrAttackHeld && IsShortcutDown(_zoomMainKey, _zoomModifiers))
		{
			_manualAimLatched = true;
			_manualAimWeapon = weapon;
		}
	}

	private static void BindShortcutEvents()
	{
		RefreshShortcutCache();
		_bowZoomHotkey.SettingChanged += ShortcutSettingChanged;
		_bowDrawCancelHotkey.SettingChanged += ShortcutSettingChanged;
		_shortcutEventsBound = true;
	}

	private static void UnbindShortcutEvents()
	{
		if (_shortcutEventsBound)
		{
			_bowZoomHotkey.SettingChanged -= ShortcutSettingChanged;
			_bowDrawCancelHotkey.SettingChanged -= ShortcutSettingChanged;
			_shortcutEventsBound = false;
		}
	}

	private static void ShortcutSettingChanged(object sender, EventArgs eventArgs)
	{
		RefreshShortcutCache();
		ClearManualAimLatch();
	}

	private static void RefreshShortcutCache()
	{
		//IL_0005: 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)
		CacheShortcut(_bowZoomHotkey.Value, out _zoomMainKey, out _zoomModifiers);
		CacheShortcut(_bowDrawCancelHotkey.Value, out _cancelMainKey, out _cancelModifiers);
	}

	private static void CacheShortcut(KeyboardShortcut shortcut, out KeyCode mainKey, out KeyCode[] modifiers)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Expected I4, but got Unknown
		mainKey = (KeyCode)(int)((KeyboardShortcut)(ref shortcut)).MainKey;
		modifiers = ((KeyboardShortcut)(ref shortcut)).Modifiers.ToArray();
	}

	private static bool IsShortcutHeld(KeyCode mainKey, KeyCode[] modifiers)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		if ((int)mainKey != 0 && UnityInput.Current.GetKey(mainKey))
		{
			return AreModifiersHeld(modifiers);
		}
		return false;
	}

	private static bool IsShortcutDown(KeyCode mainKey, KeyCode[] modifiers)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		if ((int)mainKey != 0 && UnityInput.Current.GetKeyDown(mainKey))
		{
			return AreModifiersHeld(modifiers);
		}
		return false;
	}

	private static bool AreModifiersHeld(KeyCode[] modifiers)
	{
		for (int i = 0; i < modifiers.Length; i++)
		{
			if (!UnityInput.Current.GetKey(modifiers[i]))
			{
				return false;
			}
		}
		return true;
	}

	private static void ClearManualAimLatch()
	{
		_manualAimLatched = false;
		_manualAimWeapon = null;
	}

	private static float GetZoomInTime(Player player, ItemData weapon)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		if (_bowZoomConstantTime.Value > 0f)
		{
			return _bowZoomConstantTime.Value;
		}
		float num = ((weapon?.m_shared == null) ? 0f : ((Character)player).GetSkillFactor(weapon.m_shared.m_skillType));
		return Mathf.Max(0.1f, 2f * (1f - num));
	}

	private static void ResetZoomTiming()
	{
		_wantedZoomLastFrame = false;
		_zoomDurationWeapon = null;
		_zoomInDuration = 0.3f;
	}

	private static void UpdateForcedWalk(Player player, bool wasDrawing)
	{
		if (!_movementReductionEnabled.Value || !_drawing)
		{
			if (_forcedWalk && (Object)(object)player != (Object)null)
			{
				((Character)player).SetWalk(false);
			}
			_forcedWalk = false;
		}
		else if (!wasDrawing && !((Character)player).GetWalk())
		{
			((Character)player).SetWalk(true);
			_forcedWalk = true;
		}
	}

	private static void StopPlayerEffects()
	{
		if (_forcedWalk && (Object)(object)_trackedPlayer != (Object)null)
		{
			((Character)_trackedPlayer).SetWalk(false);
		}
		_forcedWalk = false;
		_drawing = false;
		ClearManualAimLatch();
	}

	private static bool IsLocalBowAttack(Attack attack)
	{
		if (attack != null && (Object)(object)AttackCharacter.Invoke(attack) == (Object)(object)Player.m_localPlayer)
		{
			return IsBow(AttackWeapon.Invoke(attack));
		}
		return false;
	}

	private static bool IsBow(ItemData item)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Invalid comparison between Unknown and I4
		if (item?.m_shared != null)
		{
			return (int)item.m_shared.m_itemType == 4;
		}
		return false;
	}

	private static bool IsSecondaryBowDrawHeld(ItemData weapon, bool secondaryAttackHold)
	{
		if (secondaryAttackHold && IsBow(weapon) && weapon.m_shared.m_secondaryAttack != null)
		{
			return weapon.m_shared.m_secondaryAttack.m_bowDraw;
		}
		return false;
	}
}
internal static class ConfigLayout
{
	internal const string AAABuildMenu = "AAABuildMenu";

	internal const string AdventureBackpacks = "AdventureBackpacks";

	internal const string AzuAutoStore = "AzuAutoStore";

	internal const string AzuCraftyBoxes = "AzuCraftyBoxes";

	internal const string BalrondArsenal = "Balrond Arsenal";

	internal const string BossAdd = "BossAdd";

	internal const string BowAim = "Bow - Aim";

	internal const string BowGeneral = "Bow - General";

	internal const string BowPhysics = "Bow - Physics";

	internal const string ContainerLoot = "Container Loot";

	internal const string EpicLoot = "Epic Loot";

	internal const string ExpandedDungeonsGeneration = "Expanded Dungeons - Generation";

	internal const string ExpandedDungeonsTargets = "Expanded Dungeons - Room Targets";

	internal const string InventoryAutoSort = "Inventory Auto-Sort";

	internal const string MoreWorldLocations = "More World Locations";

	internal const string NetworkCleanup = "Network Cleanup";

	internal const string SunkenCrypt = "Sunken Crypt";

	internal const string Wisplight = "Wisplight";

	private static readonly HashSet<ConfigDefinition> ExistingDefinitions = new HashSet<ConfigDefinition>();

	private static readonly HashSet<string> RetiredSections = new HashSet<string>(StringComparer.Ordinal)
	{
		"5 - UI Features", "AAABuildMenu compatibility", "AdventureBackpacks UI", "Arrow Physics", "AzuAutoStore compatibility", "Balrond Amazing Nature compatibility", "BossAdd compatibility", "Bow Aim", "Container loot compatibility", "Demister",
		"Experimental", "Fixes", "Global Fix Switches", "Huginn Map", "Inventory Stats Panel", "InventorySlots Trash", "More World Locations compatibility", "Network cleanup safety"
	};

	internal static void Begin(ConfigFile config)
	{
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Expected O, but got Unknown
		ExistingDefinitions.Clear();
		if (config == null || !File.Exists(config.ConfigFilePath))
		{
			return;
		}
		string text = string.Empty;
		string[] array = File.ReadAllLines(config.ConfigFilePath);
		for (int i = 0; i < array.Length; i++)
		{
			string text2 = array[i].Trim();
			if (text2.Length == 0 || text2.StartsWith("#", StringComparison.Ordinal))
			{
				continue;
			}
			if (text2.StartsWith("[", StringComparison.Ordinal) && text2.EndsWith("]", StringComparison.Ordinal))
			{
				text = text2.Substring(1, text2.Length - 2);
				continue;
			}
			int num = text2.IndexOf('=');
			if (num > 0 && text.Length != 0)
			{
				string text3 = text2.Substring(0, num).Trim();
				if (text3.Length > 0)
				{
					ExistingDefinitions.Add(new ConfigDefinition(text, text3));
				}
			}
		}
	}

	internal static ConfigEntry<T> Bind<T>(ConfigFile config, string section, string key, T defaultValue, string description, string legacySection = null, string legacyKey = null)
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Expected O, but got Unknown
		object[] array = ((!key.StartsWith("Enable ", StringComparison.Ordinal)) ? Array.Empty<object>() : new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 1000
			}
		});
		return Bind(config, section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, array), legacySection, legacyKey);
	}

	internal static ConfigEntry<T> Bind<T>(ConfigFile config, string section, string key, T defaultValue, ConfigDescription description, string legacySection = null, string legacyKey = null)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		ConfigDefinition val = new ConfigDefinition(section, key);
		bool flag = ExistingDefinitions.Contains(val);
		bool flag2 = false;
		T value = defaultValue;
		if (!string.IsNullOrEmpty(legacySection))
		{
			ConfigDefinition val2 = new ConfigDefinition(legacySection, string.IsNullOrEmpty(legacyKey) ? key : legacyKey);
			if (ExistingDefinitions.Contains(val2))
			{
				ConfigEntry<T> val3 = config.Bind<T>(val2, defaultValue, description);
				if (!flag)
				{
					value = val3.Value;
					flag2 = true;
				}
				config.Remove(val2);
			}
		}
		ConfigEntry<T> val4 = config.Bind<T>(val, defaultValue, description);
		if (flag2)
		{
			val4.Value = value;
		}
		return val4;
	}

	internal static void RemoveRetiredEntries(ConfigFile config)
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Expected O, but got Unknown
		if (config == null || ExistingDefinitions.Count == 0)
		{
			ExistingDefinitions.Clear();
			return;
		}
		foreach (ConfigDefinition existingDefinition in ExistingDefinitions)
		{
			if (RetiredSections.Contains(existingDefinition.Section))
			{
				try
				{
					config.Bind<string>(existingDefinition, string.Empty, new ConfigDescription(string.Empty, (AcceptableValueBase)null, Array.Empty<object>()));
					config.Remove(existingDefinition);
				}
				catch (Exception exception)
				{
					VHModpackFixPlugin.LogWarning("Could not remove retired config entry [" + existingDefinition.Section + "] " + existingDefinition.Key, exception);
				}
			}
		}
		ExistingDefinitions.Clear();
	}
}
internal sealed class ConfigurationManagerAttributes
{
	public int? Order { get; set; }
}
internal static class ContainerLootSafetyFixes
{
	private static ConfigEntry<bool> _enabled;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Expected O, but got Unknown
		_enabled = ConfigLayout.Bind(config, "Container Loot", "Validate default loot before generation", defaultValue: true, "Removes only unusable default-loot entries immediately before a container rolls its initial contents. An entry is unusable when it has no prefab, ItemDrop component, item data, or shared item data. This prevents DropTable.AddItemToList null-reference errors without scanning the world or changing valid loot.", "Container loot compatibility");
		MethodInfo methodInfo = AccessTools.Method(typeof(Container), "AddDefaultItems", (Type[])null, (Type[])null);
		if (methodInfo == null)
		{
			VHModpackFixPlugin.LogWarning("Container.AddDefaultItems was not found; default-loot validation was skipped.", null);
			return;
		}
		try
		{
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(ContainerLootSafetyFixes), "ValidateDefaultLootPrefix", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			VHModpackFixPlugin.LogInfo("Container default-loot validation installed at generation time.");
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("Could not install container default-loot validation", exception);
		}
	}

	private static void ValidateDefaultLootPrefix(Container __instance)
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		ConfigEntry<bool> enabled = _enabled;
		if (enabled == null || !enabled.Value || !Object.op_Implicit((Object)(object)__instance))
		{
			return;
		}
		List<DropData> list = __instance.m_defaultItems?.m_drops;
		if (list == null || list.Count == 0)
		{
			return;
		}
		List<string> list2 = null;
		for (int num = list.Count - 1; num >= 0; num--)
		{
			if (!IsUsableDrop(list[num], out var reason))
			{
				if (list2 == null)
				{
					list2 = new List<string>();
				}
				list2.Add(reason);
				list.RemoveAt(num);
			}
		}
		if (list2 != null)
		{
			string text = Utils.GetPrefabName(((Component)__instance).gameObject);
			if (string.IsNullOrEmpty(text))
			{
				text = ((Object)((Component)__instance).gameObject).name;
			}
			list2.Reverse();
			VHModpackFixPlugin.LogWarning(string.Format("Removed {0} invalid default-loot entr{1} ", list2.Count, (list2.Count == 1) ? "y" : "ies") + "from container '" + text + "': " + string.Join(", ", list2) + ".", null);
		}
	}

	private static bool IsUsableDrop(DropData drop, out string reason)
	{
		//IL_0000: 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_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		if (!Object.op_Implicit((Object)(object)drop.m_item))
		{
			reason = "<null or destroyed prefab>";
			return false;
		}
		string text = (string.IsNullOrEmpty(((Object)drop.m_item).name) ? "<unnamed prefab>" : ((Object)drop.m_item).name);
		ItemDrop component = drop.m_item.GetComponent<ItemDrop>();
		if (!Object.op_Implicit((Object)(object)component))
		{
			reason = text + " (missing ItemDrop)";
			return false;
		}
		if (component.m_itemData == null)
		{
			reason = text + " (missing item data)";
			return false;
		}
		if (component.m_itemData.m_shared == null)
		{
			reason = text + " (missing shared item data)";
			return false;
		}
		reason = null;
		return true;
	}
}
internal static class DemisterFixes
{
	private enum EmissionJobKind
	{
		MistBoundary,
		DistantMister
	}

	private readonly struct DemisterSnapshot
	{
		internal readonly int InstanceId;

		internal readonly Vector3 Position;

		internal readonly float Radius;

		internal DemisterSnapshot(int instanceId, Vector3 position, float radius)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			InstanceId = instanceId;
			Position = position;
			Radius = radius;
		}
	}

	private readonly struct MisterSnapshot
	{
		internal readonly int InstanceId;

		internal readonly Vector3 Position;

		internal readonly float Radius;

		internal readonly float MaxAltitude;

		internal MisterSnapshot(int instanceId, Vector3 position, float radius, float maxAltitude)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			InstanceId = instanceId;
			Position = position;
			Radius = radius;
			MaxAltitude = maxAltitude;
		}
	}

	private struct EmissionJob
	{
		internal EmissionJobKind Kind;

		internal int Remaining;

		internal Vector3 Center;

		internal Vector3 Origin;

		internal float Radius;

		internal float Thickness;

		internal float MinAltitude;

		internal float MaxAltitude;

		internal int IgnoredDemisterId;

		internal int IgnoredMisterId;
	}

	private sealed class MistRuntimeState
	{
		internal readonly ParticleMist Owner;

		internal readonly ParticleSystem ParticleSystem;

		internal readonly Queue<EmissionJob> Jobs = new Queue<EmissionJob>(128);

		internal readonly List<DemisterSnapshot> Demisters = new List<DemisterSnapshot>(128);

		internal readonly List<MisterSnapshot> Misters = new List<MisterSnapshot>(128);

		internal long RemainingCandidates;

		internal float DrainDeadline;

		internal float SnapshotCreatedAt;

		internal int FrameBudget;

		internal int LastUpdateFrame;

		internal bool EpochBuilding;

		internal bool CapturedThisUpdate;

		internal MistRuntimeState(ParticleMist owner, ParticleSystem particleSystem)
		{
			Owner = owner;
			ParticleSystem = particleSystem;
			LastUpdateFrame = Time.frameCount;
		}
	}

	[HarmonyPatch(typeof(Demister), "Awake")]
	[HarmonyAfter(new string[] { "randyknapp.mods.epicloot" })]
	private static class DemisterAwakePatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Demister __instance)
		{
			ApplyMultipliers(__instance);
		}
	}

	[HarmonyPatch(typeof(Demister), "OnDisable")]
	private static class DemisterOnDisablePatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return _optimizationActive;
		}

		private static void Postfix(Demister __instance)
		{
			if ((Object)(object)__instance != (Object)null)
			{
				WisplightDemisters.Remove(((Object)__instance).GetInstanceID());
			}
		}
	}

	[HarmonyPatch(typeof(Demister), "OnEnable")]
	private static class DemisterOnEnablePatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return _optimizationActive;
		}

		private static void Postfix(Demister __instance)
		{
			if (IsWisplight(__instance))
			{
				WisplightDemisters.Add(((Object)__instance).GetInstanceID());
			}
		}
	}

	[HarmonyPatch(typeof(ParticleMist), "Awake")]
	private static class ParticleMistAwakePatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return _optimizationActive;
		}

		[HarmonyPriority(0)]
		private static void Postfix(ParticleMist __instance)
		{
			RegisterMistSystem(__instance);
		}
	}

	[HarmonyPatch(typeof(ParticleMist), "OnDestroy")]
	private static class ParticleMistOnDestroyPatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return _optimizationActive;
		}

		private static void Prefix(ParticleMist __instance)
		{
			UnregisterMistSystem(__instance);
		}
	}

	[HarmonyPatch(typeof(ParticleMist), "Update")]
	[HarmonyAfter(new string[] { "server_devcommands" })]
	private static class ParticleMistSkippedUpdateCleanupPatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return _optimizationActive;
		}

		[HarmonyPrefix]
		[HarmonyPriority(200)]
		private static void ObserveSkippedOriginal(ParticleMist __instance, bool __runOriginal)
		{
			if (!__runOriginal && TryGetMistState(__instance, out var state))
			{
				CancelPendingEmission(state);
			}
		}
	}

	[HarmonyPatch(typeof(ParticleMist), "Update")]
	[HarmonyAfter(new string[] { "server_devcommands" })]
	private static class ParticleMistUpdatePatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return _optimizationActive;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return OptimizeMistUpdateTiming(instructions);
		}

		[HarmonyPriority(0)]
		private static bool Prefix(ParticleMist __instance, ParticleSystem ___m_ps, bool __runOriginal, ref float ___m_accumulator)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetMistState(__instance, out var state))
			{
				return true;
			}
			if (!__runOriginal)
			{
				CancelPendingEmission(state);
				return true;
			}
			int frameCount = Time.frameCount;
			if (state.RemainingCandidates > 0 && frameCount - state.LastUpdateFrame > 1)
			{
				CancelPendingEmission(state);
			}
			state.LastUpdateFrame = frameCount;
			state.CapturedThisUpdate = false;
			if (!((Object)(object)___m_ps == (Object)null))
			{
				EmissionModule emission = ___m_ps.emission;
				if (((EmissionModule)(ref emission)).enabled && !((Object)(object)Player.m_localPlayer == (Object)null) && Mister.GetMisters().Count != 0)
				{
					AdvanceHeightSampler(__instance);
					DrainEmissionJobs();
					if (state.RemainingCandidates <= 0)
					{
						return true;
					}
					___m_accumulator = Mathf.Min(0.1f, ___m_accumulator + Mathf.Max(0f, Time.deltaTime));
					return false;
				}
			}
			CancelPendingEmission(state);
			return true;
		}

		[HarmonyPriority(0)]
		private static void Postfix(ParticleMist __instance)
		{
			CloseEmissionEpoch(__instance);
		}
	}

	[HarmonyPatch(typeof(ParticleMist), "FindMaxMistAlltitude")]
	private static class ParticleMistHeightPatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return _optimizationActive;
		}

		[HarmonyPriority(0)]
		private static bool Prefix(ParticleMist __instance, float testRange, ref float minMistHeight, ref float maxMistHeight)
		{
			return !TryGetRollingMistHeight(__instance, testRange, out minMistHeight, out maxMistHeight);
		}
	}

	[HarmonyPatch(typeof(ParticleMist), "Emit")]
	private static class ParticleMistEmitPatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return _optimizationActive;
		}

		[HarmonyPriority(0)]
		private static bool Prefix(ParticleMist __instance, Vector3 center, float radius, float thickness, ref int toEmit, List<Demister> fields, Demister pf, float minAlt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return CaptureEmit(__instance, center, radius, thickness, ref toEmit, fields, pf, minAlt);
		}
	}

	[HarmonyPatch(typeof(ParticleMist), "MisterEmit")]
	private static class ParticleMistMisterEmitPatch
	{
		[HarmonyPrepare]
		private static bool Prepare()
		{
			return _optimizationActive;
		}

		[HarmonyPriority(0)]
		private static bool Prefix(ParticleMist __instance, Mister mister, List<Mister> allMisters, List<Demister> fields, float minAlt, float dt)
		{
			return CaptureMisterEmit(__instance, mister, fields, minAlt, dt);
		}
	}

	private const string EpicLootGuid = "randyknapp.mods.epicloot";

	private const string WisplightBallPrefabName = "demister_ball";

	private const string GlobalMistObjectName = "Mistlands_Globalmist";

	private const string ThickMistObjectName = "ThickMist";

	private const float VanillaWisplightRadius = 10f;

	private const float MistUpdateInterval = 0.1f;

	private const int HeightSampleWindowSize = 20;

	private const int HeightSamplesPerFrameLimit = 2;

	private const float HeightSamplesPerSecond = 120f;

	private const float VanillaHeightSampleRange = 50f;

	private const float EmissionCandidatesPerSecond = 3840f;

	private const float MaxEmissionSnapshotAge = 0.25f;

	private const int MaxEmissionCandidatesPerFrame = 64;

	private const int MaxEmissionCandidatesPerJobTurn = 8;

	private const string ServerDevcommandsGuid = "server_devcommands";

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

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

	private static readonly List<MistRuntimeState> MistSystemOrder = new List<MistRuntimeState>(2);

	private static readonly float[] HeightSamples = new float[20];

	private static ConfigEntry<bool> _optimizationEnabled;

	private static ConfigEntry<float> _radiusMultiplier;

	private static ConfigEntry<float> _dispersalSpeedMultiplier;

	private static bool _optimizationActive;

	private static bool _mistTimingPatchInstalled;

	private static bool _mistTimingPatchRejected;

	private static int _heightSampleCount;

	private static int _heightSampleNext;

	private static float _heightSampleSum;

	private static float _heightSampleRange;

	private static Vector3 _heightSampleCenter;

	private static float _heightSampleCredit;

	private static int _heightSamplerFrame = -1;

	private static int _emissionDrainFrame = -1;

	private static int _emissionDrainStart;

	private static float _emissionCandidateCredit;

	internal static void Bind(ConfigFile config)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Expected O, but got Unknown
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Expected O, but got Unknown
		_optimizationEnabled = ConfigLayout.Bind(config, "Wisplight", "Enable Wisplight optimization", defaultValue: true, new ConfigDescription("Reduces Mistlands stutter by correcting the vanilla mist update rate and spreading terrain checks and particle preparation across nearby frames. Enlarged Wisplight radii keep a vanilla-sized particle workload without reducing the real clearing radius, movement response, particle limit, or visual sorting. Requires a full Valheim restart after changing this setting.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 300
			}
		}));
		_radiusMultiplier = ConfigLayout.Bind(config, "Wisplight", "Radius multiplier", 1f, new ConfigDescription("Multiplies the mist-clearing radius of the Wisplight's Demister field. 1 is the vanilla radius. Re-equip the Wisplight after changing this value.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 3f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 200
			}
		}), "Demister");
		_dispersalSpeedMultiplier = ConfigLayout.Bind(config, "Wisplight", "Dispersal speed multiplier", 1f, new ConfigDescription("Multiplies the vanilla force used by the Wisplight to push mist away. 1 is vanilla speed. Re-equip the Wisplight after changing this value.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 100
			}
		}), "Demister");
		_optimizationActive = _optimizationEnabled.Value;
	}

	internal static void Reset()
	{
		WisplightDemisters.Clear();
		MistSystems.Clear();
		MistSystemOrder.Clear();
		ResetHeightSampler();
		_emissionDrainFrame = -1;
		_emissionDrainStart = 0;
		_emissionCandidateCredit = 0f;
		_mistTimingPatchInstalled = false;
		_mistTimingPatchRejected = false;
		_optimizationActive = false;
	}

	private static void ApplyMultipliers(Demister demister)
	{
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		if (!IsWisplight(demister))
		{
			return;
		}
		ParticleSystemForceField forceField = demister.m_forceField;
		if (!((Object)(object)forceField == (Object)null))
		{
			float num = _radiusMultiplier?.Value ?? 1f;
			if (!Mathf.Approximately(num, 1f))
			{
				forceField.endRange *= num;
			}
			float num2 = _dispersalSpeedMultiplier?.Value ?? 1f;
			if (!Mathf.Approximately(num2, 1f))
			{
				forceField.gravity = Multiply(forceField.gravity, num2);
			}
		}
	}

	private static MinMaxCurve Multiply(MinMaxCurve curve, float multiplier)
	{
		//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_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected I4, but got Unknown
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		ParticleSystemCurveMode mode = ((MinMaxCurve)(ref curve)).mode;
		switch ((int)mode)
		{
		case 0:
			((MinMaxCurve)(ref curve)).constant = ((MinMaxCurve)(ref curve)).constant * multiplier;
			break;
		case 3:
			((MinMaxCurve)(ref curve)).constantMin = ((MinMaxCurve)(ref curve)).constantMin * multiplier;
			((MinMaxCurve)(ref curve)).constantMax = ((MinMaxCurve)(ref curve)).constantMax * multiplier;
			break;
		case 1:
		case 2:
			((MinMaxCurve)(ref curve)).curveMultiplier = ((MinMaxCurve)(ref curve)).curveMultiplier * multiplier;
			break;
		}
		return curve;
	}

	private static bool IsWisplight(Demister demister)
	{
		Transform val = (((Object)(object)demister == (Object)null) ? null : ((Component)demister).transform.root);
		if ((Object)(object)val != (Object)null)
		{
			return Utils.GetPrefabName(((Component)val).gameObject) == "demister_ball";
		}
		return false;
	}

	private static bool IsSupportedMistSystem(ParticleMist particleMist)
	{
		if ((Object)(object)particleMist == (Object)null)
		{
			return false;
		}
		string prefabName = Utils.GetPrefabName(((Component)particleMist).gameObject);
		if (!(prefabName == "Mistlands_Globalmist"))
		{
			return prefabName == "ThickMist";
		}
		return true;
	}

	private static bool IsOptimizedMistSystem(ParticleMist particleMist)
	{
		if (_optimizationActive && _mistTimingPatchInstalled && (Object)(object)particleMist != (Object)null)
		{
			return MistSystems.ContainsKey(((Object)particleMist).GetInstanceID());
		}
		return false;
	}

	private static bool TryGetMistState(ParticleMist particleMist, out MistRuntimeState state)
	{
		state = null;
		if (_optimizationActive && _mistTimingPatchInstalled && (Object)(object)particleMist != (Object)null)
		{
			return MistSystems.TryGetValue(((Object)particleMist).GetInstanceID(), out state);
		}
		return false;
	}

	private static void RegisterMistSystem(ParticleMist particleMist)
	{
		if (_optimizationActive && _mistTimingPatchInstalled && IsSupportedMistSystem(particleMist))
		{
			int instanceID = ((Object)particleMist).GetInstanceID();
			if (!MistSystems.ContainsKey(instanceID))
			{
				MistRuntimeState mistRuntimeState = new MistRuntimeState(particleMist, ((Component)particleMist).GetComponent<ParticleSystem>());
				MistSystems.Add(instanceID, mistRuntimeState);
				MistSystemOrder.Add(mistRuntimeState);
				VHModpackFixPlugin.LogInfo("Wisplight mist optimization activated for " + Utils.GetPrefabName(((Component)particleMist).gameObject) + ".");
			}
		}
	}

	private static void UnregisterMistSystem(ParticleMist particleMist)
	{
		if ((Object)(object)particleMist == (Object)null)
		{
			return;
		}
		int instanceID = ((Object)particleMist).GetInstanceID();
		if (MistSystems.TryGetValue(instanceID, out var value))
		{
			CancelPendingEmission(value);
			MistSystems.Remove(instanceID);
			MistSystemOrder.Remove(value);
			if (_emissionDrainStart >= MistSystemOrder.Count)
			{
				_emissionDrainStart = 0;
			}
		}
		ResetHeightSampler();
	}

	private static float GetMistUpdateDeltaTime(ParticleMist particleMist)
	{
		if (!IsOptimizedMistSystem(particleMist))
		{
			return Time.fixedDeltaTime;
		}
		return Time.deltaTime;
	}

	private static void LimitBoundaryEmission(ParticleMist particleMist, float radius, ref int toEmit, Demister demister)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		if (IsOptimizedMistSystem(particleMist) && !((Object)(object)demister == (Object)null) && !(radius <= 10f) && WisplightDemisters.Contains(((Object)demister).GetInstanceID()))
		{
			float centerDistance = Vector3.Distance(((Component)demister).transform.position, ((Component)particleMist).transform.position);
			int enlargedBoundaryEmission = CalculateBoundaryEmission(particleMist, centerDistance, radius);
			int vanillaBoundaryEmission = CalculateBoundaryEmission(particleMist, centerDistance, 10f);
			toEmit = PreserveMovementEmission(toEmit, enlargedBoundaryEmission, vanillaBoundaryEmission);
		}
	}

	private static int CalculateBoundaryEmission(ParticleMist particleMist, float centerDistance, float radius)
	{
		float num = Mathf.Max(0f, centerDistance - radius);
		if (num > particleMist.m_maxDistance)
		{
			return 0;
		}
		float num2 = Mathf.Lerp(particleMist.m_emissionMax, 0f, Utils.LerpStep(particleMist.m_minDistance, particleMist.m_maxDistance, num));
		return (int)((float)Math.PI * 4f * (radius * radius) * num2 * 0.1f);
	}

	private static int PreserveMovementEmission(int totalEmission, int enlargedBoundaryEmission, int vanillaBoundaryEmission)
	{
		return Math.Max(0, totalEmission - enlargedBoundaryEmission + vanillaBoundaryEmission);
	}

	private static bool BeginEmissionEpoch(ParticleMist particleMist, List<Demister> demisters, out MistRuntimeState state)
	{
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: 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)
		if (!TryGetMistState(particleMist, out state))
		{
			return false;
		}
		if (!state.EpochBuilding)
		{
			if (state.RemainingCandidates > 0)
			{
				return false;
			}
			state.Demisters.Clear();
			for (int i = 0; i < demisters.Count; i++)
			{
				Demister val = demisters[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.m_forceField == (Object)null))
				{
					state.Demisters.Add(new DemisterSnapshot(((Object)val).GetInstanceID(), ((Component)val).transform.position, val.m_forceField.endRange));
				}
			}
			state.Misters.Clear();
			List<Mister> misters = Mister.GetMisters();
			for (int j = 0; j < misters.Count; j++)
			{
				Mister val2 = misters[j];
				if (!((Object)(object)val2 == (Object)null))
				{
					Vector3 position = ((Component)val2).transform.position;
					state.Misters.Add(new MisterSnapshot(((Object)val2).GetInstanceID(), position, val2.m_radius, position.y + val2.m_height));
				}
			}
			state.SnapshotCreatedAt = Time.time;
			state.EpochBuilding = true;
		}
		state.CapturedThisUpdate = true;
		return true;
	}

	private static void CloseEmissionEpoch(ParticleMist particleMist)
	{
		if (TryGetMistState(particleMist, out var state) && state.CapturedThisUpdate)
		{
			state.CapturedThisUpdate = false;
			state.EpochBuilding = false;
			if (state.RemainingCandidates > 0)
			{
				state.DrainDeadline = Time.time + 0.1f;
			}
			else
			{
				ReleaseEmissionSnapshot(state);
			}
		}
	}

	private static bool CaptureEmit(ParticleMist particleMist, Vector3 center, float radius, float thickness, ref int toEmit, List<Demister> demisters, Demister ignoredDemister, float minAltitude)
	{
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: 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_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		if (!IsOptimizedMistSystem(particleMist))
		{
			return true;
		}
		LimitBoundaryEmission(particleMist, radius, ref toEmit, ignoredDemister);
		if (!BeginEmissionEpoch(particleMist, demisters, out var state))
		{
			return false;
		}
		int ignoredDemisterId = ((!((Object)(object)ignoredDemister == (Object)null)) ? ((Object)ignoredDemister).GetInstanceID() : 0);
		if (toEmit <= 0 || !InsideMister(state.Misters, center, radius + thickness) || IsInsideOtherDemister(state.Demisters, center, radius + thickness, ignoredDemisterId))
		{
			return false;
		}
		EnqueueEmission(state, new EmissionJob
		{
			Kind = EmissionJobKind.MistBoundary,
			Remaining = toEmit,
			Center = center,
			Origin = ((Component)particleMist).transform.position,
			Radius = radius,
			Thickness = thickness,
			MinAltitude = minAltitude,
			IgnoredDemisterId = ignoredDemisterId
		});
		return false;
	}

	private static bool CaptureMisterEmit(ParticleMist particleMist, Mister mister, List<Demister> demisters, float minAltitude, float deltaTime)
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: 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_010f: Unknown result type (might be due to invalid IL or missing references)
		if (!IsOptimizedMistSystem(particleMist))
		{
			return true;
		}
		if (!BeginEmissionEpoch(particleMist, demisters, out var state))
		{
			return false;
		}
		Vector3 position = ((Component)mister).transform.position;
		float radius = mister.m_radius;
		int instanceID = ((Object)mister).GetInstanceID();
		float num = Mathf.Max(0f, Vector3.Distance(position, ((Component)particleMist).transform.position) - radius);
		if (num > particleMist.m_distantMaxRange || IsCompletelyInsideOtherMister(state.Misters, position, radius, position.y + mister.m_height, instanceID, particleMist.m_distantThickness))
		{
			return false;
		}
		float num2 = (float)Math.PI * 4f * (radius * radius);
		float num3 = Mathf.Lerp(particleMist.m_distantEmissionMax, 0f, Utils.LerpStep(0f, particleMist.m_distantMaxRange, num));
		int num4 = (int)(num2 * num3 * deltaTime);
		if (num4 <= 0)
		{
			return false;
		}
		EnqueueEmission(state, new EmissionJob
		{
			Kind = EmissionJobKind.DistantMister,
			Remaining = num4,
			Center = position,
			Origin = ((Component)particleMist).transform.position,
			Radius = radius,
			Thickness = particleMist.m_distantThickness,
			MinAltitude = minAltitude,
			MaxAltitude = position.y + mister.m_height,
			IgnoredMisterId = instanceID
		});
		return false;
	}

	private static void EnqueueEmission(MistRuntimeState state, EmissionJob job)
	{
		state.Jobs.Enqueue(job);
		state.RemainingCandidates += job.Remaining;
	}

	private static bool InsideMister(List<MisterSnapshot> misters, Vector3 point, float radius)
	{
		//IL_0016: 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_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < misters.Count; i++)
		{
			MisterSnapshot misterSnapshot = misters[i];
			float num = misterSnapshot.Radius + radius;
			Vector3 val = misterSnapshot.Position - point;
			if (((Vector3)(ref val)).sqrMagnitude < num * num && point.y - radius < misterSnapshot.MaxAltitude)
			{
				return true;
			}
		}
		return false;
	}

	private static bool IsCompletelyInsideOtherMister(List<MisterSnapshot> misters, Vector3 point, float radius, float maxAltitude, int ignoredMisterId, float thickness)
	{
		//IL_002a: 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)
		for (int i = 0; i < misters.Count; i++)
		{
			MisterSnapshot misterSnapshot = misters[i];
			if (misterSnapshot.InstanceId == ignoredMisterId)
			{
				continue;
			}
			float num = misterSnapshot.Radius - radius - thickness;
			if (num > 0f)
			{
				Vector3 val = point - misterSnapshot.Position;
				if (((Vector3)(ref val)).sqrMagnitude < num * num && maxAltitude < misterSnapshot.MaxAltitude)
				{
					return true;
				}
			}
		}
		return false;
	}

	private static bool IsInsideOtherMister(List<MisterSnapshot> misters, Vector3 point, int ignoredMisterId)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < misters.Count; i++)
		{
			MisterSnapshot misterSnapshot = misters[i];
			if (misterSnapshot.InstanceId != ignoredMisterId)
			{
				Vector3 val = point - misterSnapshot.Position;
				if (((Vector3)(ref val)).sqrMagnitude < misterSnapshot.Radius * misterSnapshot.Radius && point.y < misterSnapshot.MaxAltitude)
				{
					return true;
				}
			}
		}
		return false;
	}

	private static bool IsInsideOtherDemister(List<DemisterSnapshot> demisters, Vector3 point, float radius, int ignoredDemisterId)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		for (int i = 0; i < demisters.Count; i++)
		{
			DemisterSnapshot demisterSnapshot = demisters[i];
			if (demisterSnapshot.InstanceId == ignoredDemisterId)
			{
				continue;
			}
			float num = demisterSnapshot.Radius - radius;
			if (num > 0f)
			{
				Vector3 val = demisterSnapshot.Position - point;
				if (((Vector3)(ref val)).sqrMagnitude < num * num)
				{
					return true;
				}
			}
		}
		return false;
	}

	private static void DrainEmissionJobs()
	{
		int frameCount = Time.frameCount;
		float deltaTime = Time.deltaTime;
		if (_emissionDrainFrame == frameCount || deltaTime <= 0f || MistSystemOrder.Count == 0)
		{
			return;
		}
		_emissionDrainFrame = frameCount;
		_emissionCandidateCredit = Mathf.Min(64f, _emissionCandidateCredit + deltaTime * 3840f);
		int num = Mathf.FloorToInt(_emissionCandidateCredit);
		if (num <= 0)
		{
			return;
		}
		int num2 = 0;
		for (int i = 0; i < MistSystemOrder.Count; i++)
		{
			MistRuntimeState mistRuntimeState = MistSystemOrder[i];
			mistRuntimeState.FrameBudget = 0;
			if (!CanDrainEmission(mistRuntimeState))
			{
				if (mistRuntimeState.RemainingCandidates > 0)
				{
					CancelPendingEmission(mistRuntimeState);
				}
			}
			else
			{
				float num3 = Mathf.Max(deltaTime, mistRuntimeState.DrainDeadline - Time.time);
				double a = (double)mistRuntimeState.RemainingCandidates * (double)deltaTime / (double)num3;
				mistRuntimeState.FrameBudget = Math.Max(1, (int)Math.Min(64.0, Math.Ceiling(a)));
				num2 = Math.Min(num, num2 + mistRuntimeState.FrameBudget);
			}
		}
		if (num2 <= 0)
		{
			_emissionCandidateCredit = 0f;
			return;
		}
		int num4 = num2;
		int count = MistSystemOrder.Count;
		int num5 = _emissionDrainStart % count;
		int num6 = 0;
		while (num2 > 0 && num6 < count)
		{
			MistRuntimeState mistRuntimeState2 = MistSystemOrder[num5];
			int budget = Math.Min(num2, Math.Min(mistRuntimeState2.FrameBudget, 8));
			int num7 = DrainEmissionJobTurn(mistRuntimeState2, budget);
			num2 -= num7;
			mistRuntimeState2.FrameBudget -= num7;
			num6 = ((num7 == 0) ? (num6 + 1) : 0);
			num5 = (num5 + 1) % count;
		}
		_emissionDrainStart = num5;
		_emissionCandidateCredit = Mathf.Max(0f, _emissionCandidateCredit - (float)(num4 - num2));
	}

	private static bool CanDrainEmission(MistRuntimeState state)
	{
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		if (state.RemainingCandidates > 0 && state.Jobs.Count > 0 && (Object)(object)state.Owner != (Object)null && ((Behaviour)state.Owner).isActiveAndEnabled && ((Component)state.Owner).gameObject.activeInHierarchy && (Object)(object)state.ParticleSystem != (Object)null)
		{
			EmissionModule emission = state.ParticleSystem.emission;
			if (((EmissionModule)(ref emission)).enabled && (Object)(object)Player.m_localPlayer != (Object)null && Mister.GetMisters().Count > 0)
			{
				return Time.time - state.SnapshotCreatedAt <= 0.25f;
			}
		}
		return false;
	}

	private static int DrainEmissionJobTurn(MistRuntimeState state, int budget)
	{
		if (budget <= 0 || state.Jobs.Count == 0)
		{
			return 0;
		}
		EmissionJob emissionJob = state.Jobs.Dequeue();
		int num = Math.Min(emissionJob.Remaining, budget);
		if (emissionJob.Kind == EmissionJobKind.MistBoundary)
		{
			RunMistBoundaryChunk(state.Owner, state, emissionJob, num);
		}
		else
		{
			RunDistantMisterChunk(state.Owner, state, emissionJob, num);
		}
		emissionJob.Remaining -= num;
		state.RemainingCandidates -= num;
		if (emissionJob.Remaining > 0)
		{
			state.Jobs.Enqueue(emissionJob);
		}
		else if (state.Jobs.Count == 0)
		{
			state.RemainingCandidates = 0L;
			state.DrainDeadline = 0f;
			ReleaseEmissionSnapshot(state);
		}
		return num;
	}

	private static void CancelPendingEmission(MistRuntimeState state)
	{
		state.Jobs.Clear();
		state.RemainingCandidates = 0L;
		state.DrainDeadline = 0f;
		state.SnapshotCreatedAt = 0f;
		state.FrameBudget = 0;
		state.EpochBuilding = false;
		state.CapturedThisUpdate = false;
		ReleaseEmissionSnapshot(state);
	}

	private static void ReleaseEmissionSnapshot(MistRuntimeState state)
	{
		state.SnapshotCreatedAt = 0f;
		state.Demisters.Clear();
		state.Misters.Clear();
	}

	private static void RunMistBoundaryChunk(ParticleMist particleMist, MistRuntimeState state, EmissionJob job, int count)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: 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_001b: 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_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: 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_0074: 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_00c6: 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)
		EmitParams val = default(EmitParams);
		for (int i = 0; i < count; i++)
		{
			Vector3 onUnitSphere = Random.onUnitSphere;
			Vector3 val2 = job.Center + onUnitSphere * (job.Radius + 0.1f + Random.Range(0f, job.Thickness));
			if (!(val2.y < job.MinAltitude) && !IsInsideOtherDemister(state.Demisters, val2, 0f, job.IgnoredDemisterId) && InsideMister(state.Misters, val2, 0f))
			{
				float num = Vector3.Distance(job.Origin, val2);
				if (!(num > particleMist.m_maxDistance))
				{
					((EmitParams)(ref val)).startSize = Mathf.Lerp(particleMist.m_minSize, particleMist.m_maxSize, Utils.LerpStep(particleMist.m_minDistance, particleMist.m_maxDistance, num));
					((EmitParams)(ref val)).position = val2;
					state.ParticleSystem.Emit(val, 1);
				}
			}
		}
	}

	private static void RunDistantMisterChunk(ParticleMist particleMist, MistRuntimeState state, EmissionJob job, int count)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: 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_001b: 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_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: 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_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: 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)
		EmitParams val = default(EmitParams);
		for (int i = 0; i < count; i++)
		{
			Vector3 onUnitSphere = Random.onUnitSphere;
			Vector3 val2 = job.Center + onUnitSphere * (job.Radius + 0.1f + Random.Range(0f, job.Thickness));
			if (val2.y < job.MinAltitude)
			{
				continue;
			}
			if (val2.y > job.MaxAltitude)
			{
				val2.y = job.MaxAltitude;
			}
			if (!IsInsideOtherMister(state.Misters, val2, job.IgnoredMisterId) && !IsInsideOtherDemister(state.Demisters, val2, 0f, 0))
			{
				float num = Vector3.Distance(job.Origin, val2);
				if (!(num > particleMist.m_distantMaxRange))
				{
					((EmitParams)(ref val)).startSize = Mathf.Lerp(particleMist.m_distantMinSize, particleMist.m_distantMaxSize, Utils.LerpStep(0f, particleMist.m_distantMaxRange, num));
					((EmitParams)(ref val)).position = val2;
					Vector3 velocity = onUnitSphere * Random.Range(0f, particleMist.m_distantEmissionMaxVel);
					velocity.y = 0f;
					((EmitParams)(ref val)).velocity = velocity;
					state.ParticleSystem.Emit(val, 1);
				}
			}
		}
	}

	private static void AdvanceHeightSampler(ParticleMist particleMist)
	{
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		if (!IsOptimizedMistSystem(particleMist))
		{
			return;
		}
		int frameCount = Time.frameCount;
		if (_heightSamplerFrame != frameCount)
		{
			_heightSamplerFrame = frameCount;
			EnsureHeightSampler(particleMist, 50f);
			_heightSampleCredit = Mathf.Min(20f, _heightSampleCredit + Mathf.Max(0f, Time.deltaTime) * 120f);
			int num = Mathf.Min(2, Mathf.FloorToInt(_heightSampleCredit));
			_heightSampleCredit -= num;
			for (int i = 0; i < num; i++)
			{
				ReplaceOneHeightSample(((Component)particleMist).transform.position, _heightSampleRange);
			}
		}
	}

	private static bool TryGetRollingMistHeight(ParticleMist particleMist, float testRange, out float minMistHeight, out float maxMistHeight)
	{
		minMistHeight = 0f;
		maxMistHeight = 0f;
		if (!IsOptimizedMistSystem(particleMist))
		{
			return false;
		}
		EnsureHeightSampler(particleMist, testRange);
		minMistHeight = float.MaxValue;
		for (int i = 0; i < _heightSampleCount; i++)
		{
			minMistHeight = Mathf.Min(minMistHeight, HeightSamples[i]);
		}
		maxMistHeight = _heightSampleSum / (float)_heightSampleCount + particleMist.m_maxMistAltitude;
		return true;
	}

	private static void EnsureHeightSampler(ParticleMist particleMist, float testRange)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: 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_0086: 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)
		Vector3 position = ((Component)particleMist).transform.position;
		if (_heightSampleCount > 0 && Mathf.Approximately(testRange, _heightSampleRange))
		{
			Vector3 val = position - _heightSampleCenter;
			if (((Vector3)(ref val)).sqrMagnitude <= testRange * testRange)
			{
				_heightSampleCenter = position;
				return;
			}
		}
		ResetHeightSampler();
		float groundHeight = ZoneSystem.instance.GetGroundHeight(position);
		for (int i = 0; i < 20; i++)
		{
			HeightSamples[i] = groundHeight;
		}
		_heightSampleCount = 20;
		_heightSampleNext = 0;
		_heightSampleSum = groundHeight * 20f;
		_heightSampleRange = testRange;
		_heightSampleCenter = position;
	}

	private static void ReplaceOneHeightSample(Vector3 center, float testRange)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: 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_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: 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)
		Vector2 insideUnitCircle = Random.insideUnitCircle;
		Vector3 val = center + new Vector3(insideUnitCircle.x, 0f, insideUnitCircle.y) * testRange;
		float groundHeight = ZoneSystem.instance.GetGroundHeight(val);
		_heightSampleSum -= HeightSamples[_heightSampleNext];
		HeightSamples[_heightSampleNext] = groundHeight;
		_heightSampleSum += groundHeight;
		_heightSampleNext = (_heightSampleNext + 1) % 20;
		_heightSampleCenter = center;
	}

	private static void ResetHeightSampler()
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		_heightSampleCount = 0;
		_heightSampleNext = 0;
		_heightSampleSum = 0f;
		_heightSampleRange = 0f;
		_heightSampleCenter = Vector3.zero;
		_heightSampleCredit = 0f;
		_heightSamplerFrame = -1;
	}

	private static void DisableMistOptimizationRuntime()
	{
		for (int i = 0; i < MistSystemOrder.Count; i++)
		{
			CancelPendingEmission(MistSystemOrder[i]);
		}
		MistSystems.Clear();
		MistSystemOrder.Clear();
		ResetHeightSampler();
		_emissionDrainFrame = -1;
		_emissionDrainStart = 0;
		_emissionCandidateCredit = 0f;
		_mistTimingPatchInstalled = false;
	}

	private static IEnumerable<CodeInstruction> OptimizeMistUpdateTiming(IEnumerable<CodeInstruction> instructions)
	{
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Expected O, but got Unknown
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(Time), "fixedDeltaTime");
		MethodInfo methodInfo2 = AccessTools.Method(typeof(DemisterFixes), "GetMistUpdateDeltaTime", (Type[])null, (Type[])null);
		int index = -1;
		int num = 0;
		for (int i = 0; i < list.Count; i++)
		{
			CodeInstruction val = list[i];
			if ((val.opcode == OpCodes.Call || val.opcode == OpCodes.Callvirt) && object.Equals(val.operand, methodInfo))
			{
				index = i;
				num++;
			}
		}
		if (methodInfo == null || methodInfo2 == null || num != 1)
		{
			_mistTimingPatchRejected = true;
			DisableMistOptimizationRuntime();
			VHModpackFixPlugin.LogWarning("Wisplight optimization skipped its mist-timing repair because the current ParticleMist.Update layout did not match the supported Valheim version", null);
			return list;
		}
		if (_mistTimingPatchRejected)
		{
			return list;
		}
		CodeInstruction val2 = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
		val2.labels.AddRange(list[index].labels);
		list[index].labels.Clear();
		val2.blocks.AddRange(list[index].blocks);
		list[index].blocks.Clear();
		list[index].operand = methodInfo2;
		list[index].opcode = OpCodes.Call;
		list.Insert(index, val2);
		_mistTimingPatchInstalled = true;
		VHModpackFixPlugin.LogInfo("Wisplight mist optimization installed: scoped timing, rolling terrain sampling, shared emission queue, and enlarged-boundary normalization.");
		return list;
	}
}
internal static class EpicLootAugmentChoiceFixes
{
	private const string DialogTypeName = "EpicLoot.Crafting.AugmentChoiceDialog";

	private const string CraftSuccessDialogTypeName = "EpicLoot.Crafting.CraftSuccessDialog";

	private const float FrameWidth = 380f;

	private const float BaseFrameHeight = 550f;

	private const float ButtonWidth = 320f;

	private const float ButtonHeight = 40f;

	private const float ButtonGap = 6f;

	private const float ButtonBottomMargin = 28f;

	private const float PreviewBottom = 150f;

	private static ConfigEntry<bool> _masterSwitch;

	private static ConfigEntry<bool> _enabled;

	private static FieldInfo _nameField;

	private static FieldInfo _descriptionField;

	private static FieldInfo _iconField;

	private static FieldInfo _magicBackgroundField;

	private static FieldInfo _buttonsField;

	private static MethodInfo _convertToScrollingDescription;

	private static bool _initialized;

	private static bool _runtimeDisabled;

	private static bool _warningLogged;

	private static bool Enabled
	{
		get
		{
			if (!_runtimeDisabled)
			{
				ConfigEntry<bool> enabled = _enabled;
				if (enabled != null && enabled.Value)
				{
					return _masterSwitch?.Value ?? true;
				}
			}
			return false;
		}
	}

	internal static void Init(Harmony harmony, ConfigFile config, ConfigEntry<bool> masterSwitch)
	{
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Expected O, but got Unknown
		_masterSwitch = masterSwitch;
		_enabled = ConfigLayout.Bind(config, "Epic Loot", "Fix EpicLoot augment choice dialog", defaultValue: true, "Restores the item preview, scrolling description, and effect choices in Epic Loot's replace-effect window.", "Fixes");
		if (!_initialized && harmony != null)
		{
			Type type = AccessTools.TypeByName("EpicLoot.Crafting.AugmentChoiceDialog");
			MethodInfo methodInfo = FindShowMethod(type);
			if (!(type == null) && !(methodInfo == null))
			{
				_nameField = AccessTools.Field(type, "NameText");
				_descriptionField = AccessTools.Field(type, "Description");
				_iconField = AccessTools.Field(type, "Icon");
				_magicBackgroundField = AccessTools.Field(type, "MagicBG");
				_buttonsField = AccessTools.Field(type, "EffectChoiceButtons");
				Type type2 = AccessTools.TypeByName("EpicLoot.Crafting.CraftSuccessDialog");
				_convertToScrollingDescription = ((type2 == null) ? null : AccessTools.Method(type2, "ConvertToScrollingDescription", new Type[2]
				{
					typeof(TMP_Text),
					typeof(Transform)
				}, (Type[])null));
				MethodInfo methodInfo2 = AccessTools.Method(typeof(EpicLootAugmentChoiceFixes), "ShowPostfix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2)
				{
					priority = 0
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_initialized = true;
			}
		}
	}

	private static MethodInfo FindShowMethod(Type dialogType)
	{
		if (dialogType == null)
		{
			return null;
		}
		List<MethodInfo> declaredMethods = AccessTools.GetDeclaredMethods(dialogType);
		for (int i = 0; i < declaredMethods.Count; i++)
		{
			MethodInfo methodInfo = declaredMethods[i];
			ParameterInfo[] parameters = methodInfo.GetParameters();
			if (methodInfo.Name == "Show" && parameters.Length == 3 && parameters[0].ParameterType == typeof(ItemData))
			{
				return methodInfo;
			}
		}
		return null;
	}

	private static void ShowPostfix(object __instance, ItemData fromItem)
	{
		if (!Enabled || __instance == null || fromItem == null)
		{
			return;
		}
		try
		{
			Apply(__instance, fromItem);
		}
		catch (Exception ex)
		{
			_runtimeDisabled = true;
			if (!_warningLogged)
			{
				_warningLogged = true;
				Debug.LogWarning((object)("[VHModpackFix] Epic Loot replace-effect window fix disabled: " + ex.Message));
			}
		}
	}

	private static void Apply(object dialog, ItemData item)
	{
		Component val = (Component)((dialog is Component) ? dialog : null);
		if (val != null && !((Object)(object)InventoryGui.instance == (Object)null))
		{
			Transform obj = val.transform.Find("Frame");
			RectTransform val2 = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if (!((Object)(object)val2 == (Object)null))
			{
				List<Button> activeButtons = GetActiveButtons(dialog);
				int num = Mathf.Max(1, activeButtons.Count);
				float num2 = 550f + (float)Mathf.Max(0, num - 3) * 46f;
				val.gameObject.SetActive(true);
				val.transform.SetAsLastSibling();
				((Component)val2).gameObject.SetActive(true);
				val2.SetSizeWithCurrentAnchors((Axis)0, 380f);
				val2.SetSizeWithCurrentAnchors((Axis)1, num2);
				TMP_Text orCreateText = GetOrCreateText(dialog, val2, _nameField, InventoryGui.instance.m_recipeName, "NameText");
				TMP_Text orCreateText2 = GetOrCreateText(dialog, val2, _descriptionField, InventoryGui.instance.m_recipeDecription, "Description");
				Image orCreateImage = GetOrCreateImage(dialog, val2, _iconField, InventoryGui.instance.m_recipeIcon, "Icon");
				Image fieldValue = GetFieldValue<Image>(_magicBackgroundField, dialog);
				ConfigureName(orCreateText, val2, item);
				ConfigureMagicBackground(fieldValue, val2);
				ConfigureIcon(orCreateImage, val2, item);
				ConfigureDescription(orCreateText2, val2, item, num);
				ConfigureButtons(activeButtons, val2);
			}
		}
	}

	private static List<Button> GetActiveButtons(object dialog)
	{
		List<Button> list = new List<Button>();
		if (!(_buttonsField?.GetValue(dialog) is IEnumerable enumerable))
		{
			return list;
		}
		foreach (object item in enumerable)
		{
			Button val = (Button)((item is Button) ? item : null);
			if (val != null && (Object)(object)val != (Object)null && ((Component)val).gameObject.activeSelf)
			{
				list.Add(val);
			}
		}
		return list;
	}

	private static TMP_Text GetOrCreateText(object dialog, RectTransform frame, FieldInfo field, TMP_Text template, string objectName)
	{
		TMP_Text fieldValue = GetFieldValue<TMP_Text>(field, dialog);
		if ((Object)(object)fieldValue != (Object)null || (Object)(object)template == (Object)null)
		{
			return fieldValue;
		}
		TMP_Text val = Object.Instantiate<TMP_Text>(template, (Transform)(object)frame);
		((Object)val).name = objectName;
		field?.SetValue(dialog, val);
		return val;
	}

	private static Image GetOrCreateImage(object dialog, RectTransform frame, FieldInfo field, Image template, string objectName)
	{
		Image fieldValue = GetFieldValue<Image>(field, dialog);
		if ((Object)(object)fieldValue != (Object)null || (Object)(object)template == (Object)null)
		{
			return fieldValue;
		}
		Image val = Object.Instantiate<Image>(template, (Transform)(object)frame);
		((Object)val).name = objectName;
		field?.SetValue(dialog, val);
		return val;
	}

	private static void ConfigureName(TMP_Text text, RectTransform frame, ItemData item)
	{
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)text == (Object)null))
		{
			((Component)text).gameObject.SetActive(true);
			((Behaviour)text).enabled = true;
			text.text = EpicLootUiFixes.Localize(EpicLootUiFixes.GetDecoratedName(item));
			text.fontSize = 22f;
			text.textWrappingMode = (TextWrappingModes)1;
			text.alignment = (TextAlignmentOptions)514;
			((Graphic)text).color = Color.white;
			((Graphic)text).raycastTarget = false;
			RectTransform rectTransform = text.rectTransform;
			((Transform)rectTransform).SetParent((Transform)(object)frame, false);
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, -12f);
			rectTransform.sizeDelta = new Vector2(-28f, 48f);
			((Transform)rectTransform).SetAsLastSibling();
		}
	}

	private static void ConfigureMagicBackground(Image image, RectTransform frame)
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: 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_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: 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_0068: 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_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)image == (Object)null))
		{
			((Component)image).gameObject.SetActive(true);
			RectTransform val = (RectTransform)((Component)image).transform;
			((Transform)val).SetParent((Transform)(object)frame, false);
			val.anchorMin = new Vector2(0.5f, 1f);
			val.anchorMax = new Vector2(0.5f, 1f);
			val.pivot = new Vector2(0.5f, 0.5f);
			val.anchoredPosition = new Vector2(0f, -102f);
			val.sizeDelta = new Vector2(82f, 82f);
			((Transform)val).SetAsLastSibling();
		}
	}

	private static void ConfigureIcon(Image image, RectTransform frame, ItemData item)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_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: 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_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)image == (Object)null))
		{
			((Component)image).gameObject.SetActive(true);
			((Behaviour)image).enabled = true;
			image.sprite = item.GetIcon();
			image.preserveAspect = true;
			((Graphic)image).raycastTarget = false;
			RectTransform val = (RectTransform)((Component)image).transform;
			((Transform)val).SetParent((Transform)(object)frame, false);
			val.anchorMin = new Vector2(0.5f, 1f);
			val.anchorMax = new Vector2(0.5f, 1f);
			val.pivot = new Vector2(0.5f, 0.5f);
			val.anchoredPosition = new Vector2(0f, -102f);
			val.sizeDelta = new Vector2(72f, 72f);
			((Transform)val).SetAsLastSibling();
		}
	}

	private static void ConfigureDescription(TMP_Text text, RectTransform frame, ItemData item, int visibleButtonCount)
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_027f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02de: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)text == (Object)null)
		{
			return;
		}
		((Component)text).gameObject.SetActive(true);
		((Behaviour)text).enabled = true;
		text.text = EpicLootUiFixes.Localize(item.GetTooltip(-1));
		text.fontSize = 18f;
		text.textWrappingMode = (TextWrappingModes)1;
		text.alignment = (TextAlignmentOptions)257;
		text.overflowMode = (TextOverflowModes)0;
		((Graphic)text).color = Color.white;
		((Graphic)text).raycastTarget = false;
		Transform obj = FindAncestor(text.transform, "ScrollView");
		RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
		if ((Object)(object)val == (Object)null && _convertToScrollingDescription != null)
		{
			object? obj2 = _convertToScrollingDescription.Invoke(null, new object[2] { text, frame });
			object? obj3 = ((obj2 is ScrollRect) ? obj2 : null);
			Transform obj4 = ((obj3 != null) ? ((Component)obj3).transform : null);
			val = (RectTransform)(object)((obj4 is RectTransform) ? obj4 : null);
		}
		float num = (float)visibleButtonCount * 40f + (float)Mathf.Max(0, visibleButtonCount - 1) * 6f;
		float num2 = 28f + num + 14f;
		ScrollRect val2 = null;
		if ((Object)(object)val != (Object)null)
		{
			((Component)val).gameObject.SetActive(true);
			((Transform)val).SetParent((Transform)(object)frame, false);
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.pivot = new Vector2(0.5f, 0.5f);
			val.offsetMin = new Vector2(12f, num2);
			val.offsetMax = new Vector2(-12f, -150f);
			((Transform)val).SetAsLastSibling();
			val2 = ((Component)val).GetComponent<ScrollRect>();
			if ((Object)(object)val2 != (Object)null)
			{
				RectTransform val3 = val2.viewport;
				if ((Object)(object)val3 == (Object)null)
				{
					Transform obj5 = ((Transform)val).Find("Viewport");
					val3 = (RectTransform)(object)((obj5 is RectTransform) ? obj5 : null);
				}
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)val3).gameObject.SetActive(true);
					val3.anchorMin = Vector2.zero;
					val3.anchorMax = Vector2.one;
					val3.pivot = new Vector2(0.5f, 0.5f);
					val3.offsetMin = Vector2.zero;
					val3.offsetMax = new Vector2(-14f, 0f);
					((Transform)text.rectTransform).SetParent((Transform)(object)val3, false);
					val2.viewport = val3;
					val2.content = text.rectTransform;
				}
				val2.horizontal = false;
				val2.vertical = true;
				val2.movementType = (MovementType)2;
				val2.scrollSensitivity = 100f;
				ConfigureScrollbar(val2, val);
			}
		}
		ContentSizeFitter obj6 = ((Component)text).GetComponent<ContentSizeFitter>() ?? ((Component)text).gameObject.AddComponent<ContentSizeFitter>();
		obj6.horizontalFit = (FitMode)0;
		obj6.verticalFit = (FitMode)2;
		RectTransform rectTransform = text.rectTransform;
		rectTransform.anchorMin = new Vector2(0f, 1f);
		rectTransform.anchorMax = new Vector2(1f, 1f);
		rectTransform.pivot = new Vector2(0f, 1f);
		rectTransform.anchoredPosition = new Vector2(6f, -6f);
		rectTransform.sizeDelta = new Vector2(-12f, rectTransform.sizeDelta.y);
		text.ForceMeshUpdate(false, false);
		Canvas.ForceUpdateCanvases();
		LayoutRebuilder.ForceRebuildLayoutImmediate(rectTransform);
		if ((Object)(object)val2 != (Object)null)
		{
			if ((Object)(object)val2.viewport != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val2.viewport);
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(val);
			Canvas.ForceUpdateCanvases();
			val2.StopMovement();
			val2.verticalNormalizedPosition = 1f;
		}
	}

	private static void ConfigureScrollbar(ScrollRect scroll, RectTransform scrollView)
	{
		//IL_0066: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		Scrollbar val = scroll.verticalScrollbar ?? ((Component)scrollView).GetComponentInChildren<Scrollbar>(true);
		if (!((Object)(object)val == (Object)null))
		{
			scroll.verticalScrollbar = val;
			scroll.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			((Component)val).gameObject.SetActive(true);
			((Behaviour)val).enabled = true;
			val.direction = (Direction)2;
			Transform transform = ((Component)val).transform;
			RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val2 != null)
			{
				((Transform)val2).SetParent((Transform)(object)scrollView, false);
				val2.anchorMin = new Vector2(1f, 0f);
				val2.anchorMax = new Vector2(1f, 1f);
				val2.pivot = new Vector2(1f, 0.5f);
				val2.anchoredPosition = new Vector2(-6f, 0f);
				val2.sizeDelta = new Vector2(8f, -16f);
				((Transform)val2).SetAsLastSibling();
			}
		}
	}

	private static void ConfigureButtons(List<Button> buttons, RectTransform frame)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		int count = buttons.Count;
		for (int i = 0; i < count; i++)
		{
			Button val = buttons[i];
			if (!((Object)(object)val == (Object)null))
			{
				Transform transform = ((Component)val).transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val2 != null)
				{
					((Transform)val2).SetParent((Transform)(object)frame, false);
					val2.anchorMin = new Vector2(0.5f, 0f);
					val2.anchorMax = new Vector2(0.5f, 0f);
					val2.pivot = new Vector2(0.5f, 0.5f);
					val2.anchoredPosition = new Vector2(0f, 48f + (float)(count - 1 - i) * 46f);
					val2.SetSizeWithCurrentAnchors((Axis)0, 320f);
					val2.SetSizeWithCurrentAnchors((Axis)1, 40f);
					((Transform)val2).SetAsLastSibling();
				}
			}
		}
	}

	private static Transform FindAncestor(Transform transform, string name)
	{
		Transform val = transform;
		while ((Object)(object)val != (Object)null)
		{
			if (string.Equals(((Object)val).name, name, StringComparison.Ordinal))
			{
				return val;
			}
			val = val.parent;
		}
		return null;
	}

	private static T GetFieldValue<T>(FieldInfo field, object instance) where T : class
	{
		return field?.GetValue(instance) as T;
	}
}
internal static class EpicLootCraftyBoxesCounts
{
	private const string ElementTypeName = "EpicLoot_UnityLib.MultiSelectItemListElement";

	private const string ListTypeName = "EpicLoot_UnityLib.MultiSelectItemList";

	private const string PanelBaseTypeName = "EpicLoot_UnityLib.EnchantingTableUIPanelBase";

	private const string InventoryManagementTypeName = "EpicLoot_UnityLib.InventoryManagement";

	private const string DefaultFormat = "{0}/{1}";

	private static readonly Dictionary<Type, FieldInfo> CostListFields = new Dictionary<Type, FieldInfo>();

	private static ConfigEntry<bool> _masterSwitch;

	private static ConfigEntry<bool> _enabled;

	private static Type _listType;

	private static Type _panelBaseType;

	private static FieldInfo _itemTotalQuantityField;

	private static MethodInfo _getListElement;

	private static MethodInfo _listElementGetItem;

	private static MethodInfo _listElementGetMax;

	private static PropertyInfo _inventoryManagementInstance;

	private static MethodInfo _countItem;

	private static FieldInfo _azuResourceStringField;

	private static bool _initialized;

	private static bool _runtimeDisabled;

	private static bool _warningLogged;

	private static bool Enabled
	{
		get
		{
			if (!_runtimeDisabled)
			{
				ConfigEntry<bool> enabled = _enabled;
				if (enabled != null && enabled.Value)
				{
					return _masterSwitch?.Value ?? true;
				}
			}
			return false;
		}
	}

	internal static void Init(Harmony harmony, ConfigFile config, ConfigEntry<bool> masterSwitch)
	{
		//IL_01de: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: Expected O, but got Unknown
		_masterSwitch = masterSwitch;
		_enabled = ConfigLayout.Bind(config, "Epic Loot", "Show AzuCraftyBoxes counts in EpicLoot", defaultValue: true, "Shows available/required resources in Epic Loot enchanting costs. Nearby permitted boxes are included when AzuCraftyBoxes is installed.", "Fixes");
		if (_initialized || harmony == null)
		{
			return;
		}
		Type type = AccessTools.TypeByName("EpicLoot_UnityLib.MultiSelectItemListElement");
		_listType = AccessTools.TypeByName("EpicLoot_UnityLib.MultiSelectItemList");
		_panelBaseType = AccessTools.TypeByName("EpicLoot_UnityLib.EnchantingTableUIPanelBase");
		Type type2 = AccessTools.TypeByName("EpicLoot_UnityLib.IListElement");
		Type type3 = AccessTools.TypeByName("EpicLoot_UnityLib.InventoryManagement");
		if (!(type == null) && !(_listType == null) && !(_panelBaseType == null) && !(type2 == null) && !(type3 == null))
		{
			MethodInfo methodInfo = AccessTools.Method(type, "Refresh", Type.EmptyTypes, (Type[])null);
			_itemTotalQuantityField = AccessTools.Field(type, "ItemTotalQuantity");
			_getListElement = AccessTools.Method(type, "GetListElement", Type.EmptyTypes, (Type[])null);
			_listElementGetItem = AccessTools.Method(type2, "GetItem", Type.EmptyTypes, (Type[])null);
			_listElementGetMax = AccessTools.Method(type2, "GetMax", Type.EmptyTypes, (Type[])null);
			_inventoryManagementInstance = AccessTools.Property(type3, "Instance");
			_countItem = AccessTools.Method(type3, "CountItem", new Type[1] { typeof(string) }, (Type[])null);
			if (!(methodInfo == null) && !(_itemTotalQuantityField == null) && !(_getListElement == null) && !(_listElementGetItem == null) && !(_listElementGetMax == null) && !(_inventoryManagementInstance == null) && !(_countItem == null))
			{
				Type type4 = AccessTools.TypeByName("AzuCraftyBoxes.AzuCraftyBoxesPlugin");
				_azuResourceStringField = ((type4 == null) ? null : AccessTools.Field(type4, "resourceString"));
				MethodInfo methodInfo2 = AccessTools.Method(typeof(EpicLootCraftyBoxesCounts), "RefreshPostfix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2)
				{
					priority = 0
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_initialized = true;
			}
		}
	}

	private static void RefreshPostfix(object __instance)
	{
		if (!Enabled)
		{
			return;
		}
		Component val = (Component)((__instance is Component) ? __instance : null);
		if (val == null)
		{
			return;
		}
		try
		{
			UpdateCostText(__instance, val);
		}
		catch (Exception ex)
		{
			_runtimeDisabled = true;
			if (!_warningLogged)
			{
				_warningLogged = true;
				Debug.LogWarning((object)("[VHModpackFix] Epic Loot resource counts disabled: " + ex.Message));
			}
		}
	}

	private static void UpdateCostText(object elementInstance, Component element)
	{
		object obj = _getListElement.Invoke(elementInstance, null);
		if (obj == null || !TryFindCostList(element.transform, out var list, out var panel))
		{
			return;
		}
		FieldInfo costListField = GetCostListField(((object)panel).GetType());
		if (costListField == null || costListField.GetValue(panel) != list)
		{
			return;
		}
		object? value = _itemTotalQuantityField.GetValue(elementInstance);
		Text val = (Text)((value is Text) ? value : null);
		object? obj2 = _listElementGetItem.Invoke(obj, null);
		ItemData val2 = (ItemData)((obj2 is ItemData) ? obj2 : null);
		if ((Object)(object)val == (Object)null || val2?.m_shared == null || string.IsNullOrEmpty(val2.m_shared.m_name))
		{
			return;
		}
		int num = Convert.ToInt32(_listElementGetMax.Invoke(obj, null));
		if (num <= 0)
		{
			return;
		}
		string resourceFormat = GetResourceFormat();
		if (string.IsNullOrWhiteSpace(resourceFormat))
		{
			return;
		}
		object value2 = _inventoryManagementInstance.GetValue(null);
		if (value2 != null)
		{
			string arg = FormatThousands(Convert.ToInt32(_countItem.Invoke(value2, new object[1] { val2.m_shared.m_name })));
			string text;
			try
			{
				text = string.Format(resourceFormat, arg, num);
			}
			catch (FormatException)
			{
				text = $"{arg}/{num}";
			}
			string text2 = val.text;
			bool flag = text2 != null && text2.IndexOf("<color=red>", StringComparison.OrdinalIgnoreCase) >= 0;
			val.text = (flag ? ("<color=red>" + text + "</color>") : text);
		}
	}

	private static bool TryFindCostList(Transform start, out Component list, out Component panel)
	{
		list = null;
		panel = null;
		Transform val = start;
		while ((Object)(object)val != (Object)null)
		{
			if (list == null)
			{
				list = ((Component)val).GetComponent(_listType);
			}
			panel = ((Component)val).GetComponent(_panelBaseType);
			if ((Object)(object)panel != (Object)null)
			{
				break;
			}
			val = val.parent;
		}
		if ((Object)(object)list != (Object)null)
		{
			return (Object)(object)panel != (Object)null;
		}
		return false;
	}

	private static FieldInfo GetCostListField(Type panelType)
	{
		if (CostListFields.TryGetValue(panelType, out var value))
		{
			return value;
		}
		value = AccessTools.Field(panelType, "CostList");
		CostListFields[panelType] = value;
		return value;
	}

	private static string GetResourceFormat()
	{
		if (_azuResourceStringField?.GetValue(null) is ConfigEntry<string> val)
		{
			return val.Value;
		}
		return "{0}/{1}";
	}

	private static string FormatThousands(int number)
	{
		if (number >= 1000000)
		{
			return ((double)number / 1000000.0).ToString("0.#") + "M";
		}
		if (number >= 1000)
		{
			return ((double)number / 1000.0).ToString("0.#") + "K";
		}
		return number.ToString();
	}
}
internal static class EpicLootUiFixes
{
	private const string CraftSuccessDialogTypeName = "EpicLoot.Crafting.CraftSuccessDialog";

	private const string EnchantingTableUiTypeName = "EpicLoot_UnityLib.EnchantingTableUI";

	private const string PanelBaseTypeName = "EpicLoot_UnityLib.EnchantingTableUIPanelBase";

	private const string CloseButtonName = "VHModpackFixCloseButton";

	private static ConfigEntry<bool> _masterSwitch;

	private static ConfigEntry<bool> _enabled;

	private static FieldInfo _frameField;

	private static FieldInfo _nameField;

	private static FieldInfo _descriptionField;

	private static FieldInfo _iconField;

	private static FieldInfo _magicBackgroundField;

	private static MethodInfo _convertToScrollingDescription;

	private static MethodInfo _getDecoratedName;

	private static Type _enchantingTableUiType;

	private static PropertyInfo _enchantingTableUiInstance;

	private static FieldInfo _panelsField;

	private static FieldInfo _mainButtonField;

	private static bool _initialized;

	private static bool _runtimeDisabled;

	private static bool _warningLogged;

	private static bool Enabled
	{
		get
		{
			if (!_runtimeDisabled)
			{
				ConfigEntry<bool> enabled = _enabled;
				if (enabled != null && enabled.Value)
				{
					return _masterSwitch?.Value ?? true;
				}
			}
			return false;
		}
	}

	internal static void Init(Harmony harmony, ConfigFile config, ConfigEntry<bool> masterSwitch)
	{
		//IL_0236: Unknown result type (might be due to invalid IL or missing references)
		//IL_023b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0244: Expected O, but got Unknown
		//IL_0246: Unknown result type (might be due to invalid IL or missing references)
		//IL_024b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0254: Expected O, but got Unknown
		_masterSwitch = masterSwitch;
		_enabled = ConfigLayout.Bind(config, "Epic Loot", "Fix EpicLoot craft success dialog", defaultValue: true, "Keeps Epic Loot's success dialog populated and correctly laid out while preserving the native button style.", "Fixes");
		if (_initialized || harmony == null)
		{
			return;
		}
		Type type = AccessTools.TypeByName("EpicLoot.Crafting.CraftSuccessDialog");
		if (!(type == null))
		{
			MethodInfo methodInfo = AccessTools.Method(type, "Create", new Type[1] { typeof(Transform) }, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(type, "Show", new Type[1] { typeof(ItemData) }, (Type[])null);
			if (!(methodInfo == null) && !(methodInfo2 == null))
			{
				_frameField = AccessTools.Field(type, "Frame");
				_nameField = AccessTools.Field(type, "NameText");
				_descriptionField = AccessTools.Field(type, "Description");
				_iconField = AccessTools.Field(type, "Icon");
				_magicBackgroundField = AccessTools.Field(type, "MagicBG");
				_convertToScrollingDescription = AccessTools.Method(type, "ConvertToScrollingDescription", new Type[2]
				{
					typeof(TMP_Text),
					typeof(Transform)
				}, (Type[])null);
				_enchantingTableUiType = AccessTools.TypeByName("EpicLoot_UnityLib.EnchantingTableUI");
				Type type2 = AccessTools.TypeByName("EpicLoot_UnityLib.EnchantingTableUIPanelBase");
				_enchantingTableUiInstance = ((_enchantingTableUiType == null) ? null : AccessTools.Property(_enchantingTableUiType, "instance"));
				_panelsField = ((_enchantingTableUiType == null) ? null : AccessTools.Field(_enchantingTableUiType, "Panels"));
				_mainButtonField = ((type2 == null) ? null : AccessTools.Field(type2, "MainButton"));
				Type type3 = AccessTools.TypeByName("EpicLoot.ItemDataExtensions");
				_getDecoratedName = ((type3 == null) ? null : (AccessTools.Method(type3, "GetDecoratedName", new Type[2]
				{
					typeof(ItemData),
					typeof(string)
				}, (Type[])null) ?? AccessTools.Method(type3, "GetDecoratedName", new Type[1] { typeof(ItemData) }, (Type[])null)));
				MethodInfo methodInfo3 = AccessTools.Method(typeof(EpicLootUiFixes), "CreatePostfix", (Type[])null, (Type[])null);
				MethodInfo methodInfo4 = AccessTools.Method(typeof(EpicLootUiFixes), "ShowPostfix", (Type[])null, (Type[])null);
				HarmonyMethod val = new HarmonyMethod(methodInfo3)
				{
					priority = 0
				};
				HarmonyMethod val2 = new HarmonyMethod(methodInfo4)
				{
					priority = 0
				};
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_initialized = true;
			}
		}
	}

	private static void CreatePostfix(object __result)
	{
		if (Enabled && __result != null)
		{
			TryApply(__result, null);
		}
	}

	private static void ShowPostfix(object __instance, ItemData item)
	{
		if (Enabled && __instance != null && item != null)
		{
			TryApply(__instance, item);
		}
	}

	private static void TryApply(object dialog, ItemData item)
	{
		try
		{
			Apply(dialog, item);
		}
		catch (Exception ex)
		{
			_runtimeDisabled = true;
			if (!_warningLogged)
			{
				_warningLogged = true;
				Debug.LogWarning((object)("[VHModpackFix] Epic Loot success dialog fix disabled: " + ex.Message));
			}
		}
	}

	private static void Apply(object dialog, ItemData item)
	{
		Component val = (Component)((dialog is Component) ? dialog : null);
		if (val != null && !((Object)(object)InventoryGui.instance == (Object)null))
		{
			RectTransform val2 = (RectTransform)(((object)GetFieldValue<RectTransform>(_frameField, dialog)) ?? ((object)(/*isinst with value type is only supported in some contexts*/ ?? /*isinst with value type is only supported in some contexts*/)));
			if (!((Object)(object)val2 == (Object)null))
			{
				((Component)val2).gameObject.SetActive(true);
				val2.SetSizeWithCurrentAnchors((Axis)0, 380f);
				val2.SetSizeWithCurrentAnchors((Axis)1, 550f);
				((Transform)val2).SetAsLastSibling();
				val.transform.SetAsLastSibling();
				TMP_Text text = GetFieldValue<TMP_Text>(_nameField, dialog) ?? CreateText(dialog, val2, _nameField, InventoryGui.instance.m_recipeName, "NameText");
				TMP_Text val3 = GetFieldValue<TMP_Text>(_descriptionField, dialog) ?? CreateText(dialog, val2, _descriptionField, InventoryGui.instance.m_recipeDecription, "Description");
				Image image = GetFieldValue<Image>(_iconField, dialog) ?? CreateImage(dialog, val2, _iconField, InventoryGui.instance.m_recipeIcon, "Icon");
				Image fieldValue = GetFieldValue<Image>(_magicBackgroundField, dialog);
				EnsureScrollingDescription(val3, val2);
				ConfigureName(text, val2, item);
				ConfigureMagicBackground(fieldValue, val2);
				ConfigureIcon(image, val2, item);
				ConfigureDescription(val3, val2, item);
				ConfigureCloseButton(val, val2);
				val.gameObject.SetActive(item != null || val.gameObject.activeSelf);
			}
		}
	}

	private static TMP_Text CreateText(object dialog, RectTransform frame, FieldInfo field, TMP_Text template, string objectName)
	{
		if ((Object)(object)template == (Object)null)
		{
			return null;
		}
		TMP_Text val = Object.Instantiate<TMP_Text>(template, (Transform)(object)frame);
		((Object)val).name = objectName;
		field?.SetValue(dialog, val);
		return val;
	}

	private static Image CreateImage(object dialog, RectTransform frame, FieldInfo field, Image template, string objectName)
	{
		if ((Object)(object)template == (Object)null)
		{
			return null;
		}
		Image val = Object.Instantiate<Image>(template, (Transform)(object)frame);
		((Object)val).name = objectName;
		field?.SetValue(dialog, val);
		return val;
	}

	private static void EnsureScrollingDescription(TMP_Text description, RectTransform frame)
	{
		if (!((Object)(object)description == (Object)null) && !((Object)(object)FindAncestor(description.transform, "ScrollView") != (Object)null) && !(_convertToScrollingDescription == null))
		{
			_convertToScrollingDescription.Invoke(null, new object[2] { description, frame });
		}
	}

	private static void ConfigureName(TMP_Text text, RectTransform frame, ItemData item)
	{
		//IL_004a: 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_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)text == (Object)null))
		{
			((Component)text).gameObject.SetActive(true);
			((Behaviour)text).enabled = true;
			if (item != null)
			{
				text.text = Localize(GetDecoratedName(item));
			}
			RectTransform rectTransform = text.rectTransform;
			((Transform)rectTransform).SetParent((Transform)(object)frame, false);
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, -18f);
			rectTransform.sizeDelta = new Vector2(-32f, 44f);
		}
	}

	private static void ConfigureMagicBackground(Image image, RectTransform frame)
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: 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_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: 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_0068: 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_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)image == (Object)null))
		{
			((Component)image).gameObject.SetActive(true);
			RectTransform val = (RectTransform)((Component)image).transform;
			((Transform)val).SetParent((Transform)(object)frame, false);
			val.anchorMin = new Vector2(0.5f, 1f);
			val.anchorMax = new Vector2(0.5f, 1f);
			val.pivot = new Vector2(0.5f, 0.5f);
			val.anchoredPosition = new Vector2(0f, -86f);
			val.sizeDelta = new Vector2(82f, 82f);
			((Transform)val).SetSiblingIndex(0);
		}
	}

	private static void ConfigureIcon(Image image, RectTransform frame, ItemData item)
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: 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_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)image == (Object)null))
		{
			((Component)image).gameObject.SetActive(true);
			((Behaviour)image).enabled = true;
			image.preserveAspect = true;
			if (item != null)
			{
				image.sprite = item.GetIcon();
			}
			RectTransform val = (RectTransform)((Component)image).transform;
			((Transform)val).SetParent((Transform)(object)frame, false);
			val.anchorMin = new Vector2(0.5f, 1f);
			val.anchorMax = new Vector2(0.5f, 1f);
			val.pivot = new Vector2(0.5f, 0.5f);
			val.anchoredPosition = new Vector2(0f, -86f);
			val.sizeDelta = new Vector2(72f, 72f);
		}
	}

	private static void ConfigureDescription(TMP_Text text, RectTransform frame, ItemData item)
	{
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_0139: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: 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_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)text == (Object)null)
		{
			return;
		}
		((Component)text).gameObject.SetActive(true);
		((Behaviour)text).enabled = true;
		if (item != null)
		{
			text.text = Localize(item.GetTooltip(-1));
		}
		Transform obj = FindAncestor(text.transform, "ScrollView");
		RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
		if ((Object)(object)val != (Object)null)
		{
			((Transform)val).SetParent((Transform)(object)frame, false);
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.pivot = new Vector2(0.5f, 0.5f);
			val.offsetMin = new Vector2(12f, 58f);
			val.offsetMax = new Vector2(-12f, -138f);
			ScrollRect component = ((Component)val).GetComponent<ScrollRect>();
			if ((Object)(object)component != (Object)null)
			{
				component.horizontal = false;
				component.vertical = true;
				component.movementType = (MovementType)2;
				component.scrollSensitivity = 100f;
				ConfigureScrollbar(component, val);
			}
		}
		RectTransform rectTransform = text.rectTransform;
		rectTransform.anchorMin = new Vector2(0f, 1f);
		rectTransform.anchorMax = new Vector2(1f, 1f);
		rectTransform.pivot = new Vector2(0f, 1f);
		rectTransform.anchoredPosition = new Vector2(6f, -6f);
		rectTransform.sizeDelta = new Vector2(-12f, rectTransform.sizeDelta.y);
	}

	private static void ConfigureScrollbar(ScrollRect scroll, RectTransform scrollView)
	{
		//IL_0066: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		Scrollbar val = scroll.verticalScrollbar ?? ((Component)scrollView).GetComponentInChildren<Scrollbar>(true);
		if (!((Object)(object)val == (Object)null))
		{
			scroll.verticalScrollbar = val;
			scroll.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			((Component)val).gameObject.SetActive(true);
			((Behaviour)val).enabled = true;
			val.direction = (Direction)2;
			Transform transform = ((Component)val).transform;
			RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val2 != null)
			{
				((Transform)val2).SetParent((Transform)(object)scrollView, false);
				val2.anchorMin = new Vector2(1f, 0f);
				val2.anchorMax = new Vector2(1f, 1f);
				val2.pivot = new Vector2(1f, 0.5f);
				val2.anchoredPosition = new Vector2(-6f, 0f);
				val2.sizeDelta = new Vector2(8f, -16f);
				((Transform)val2).SetAsLastSibling();
			}
		}
	}

	private static void ConfigureCloseButton(Component root, RectTransform frame)
	{
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Expected O, but got Unknown
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Expected O, but got Unknown
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_017e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: 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_01b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
		Button val = FindOwnedCloseButton(root, frame);
		if ((Object)(object)val == (Object)null)
		{
			Button val2 = FindActiveEpicLootActionButton(root);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			RemoveObsoleteDialogButtons(root);
			val = CloneActionButton(val2, frame);
		}
		else
		{
			RemoveObsoleteDialogButtons(root);
		}
		((Object)val).name = "VHModpackFixCloseButton";
		((Component)val).gameObject.SetActive(true);
		((Behaviour)val).enabled = true;
		((Selectable)val).interactable = true;
		val.onClick = new ButtonClickedEvent();
		((UnityEvent)val.onClick).AddListener((UnityAction)delegate
		{
			root.gameObject.SetActive(false);
		});
		CanvasGroup obj = ((Component)val).GetComponent<CanvasGroup>() ?? ((Component)val).gameObject.AddComponent<CanvasGroup>();
		obj.interactable = true;
		obj.blocksRaycasts = true;
		obj.ignoreParentGroups = true;
		if ((Object)(object)((Selectable)val).targetGraphic != (Object)null)
		{
			((Behaviour)((Selectable)val).targetGraphic).enabled = true;
			((Selectable)val).targetGraphic.raycastTarget = true;
		}
		string text = Localize("$menu_close");
		Text componentInChildren = ((Component)val).GetComponentInChildren<Text>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.text = text;
			((Graphic)componentInChildren).raycastTarget = false;
		}
		else
		{
			TMP_Text componentInChildren2 = ((Component)val).GetComponentInChildren<TMP_Text>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				componentInChildren2.text = text;
				((Graphic)componentInChildren2).raycastTarget = false;
			}
		}
		Transform transform = ((Component)val).transform;
		RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
		if (val3 == null)
		{
			return;
		}
		((Transform)val3).SetParent((Transform)(object)frame, false);
		val3.anchorMin = new Vector2(0.5f, 0f);
		val3.anchorMax = new Vector2(0.5f, 0f);
		val3.pivot = new Vector2(0.5f, 0.5f);
		val3.anchoredPosition = new Vector2(0f, 34f);
		Rect rect = val3.rect;
		if (!(((Rect)(ref rect)).width < 1f))
		{
			rect = val3.rect;
			if (!(((Rect)(ref rect)).height < 1f))
			{
				goto IL_01fc;
			}
		}
		val3.SetSizeWithCurrentAnchors((Axis)0, 180f);
		val3.SetSizeWithCurrentAnchors((Axis)1, 40f);
		goto IL_01fc;
		IL_01fc:
		((Transform)val3).SetAsLastSibling();
	}

	private static Button FindOwnedCloseButton(Component root, RectTransform frame)
	{
		Button[] componentsInChildren = root.GetComponentsInChildren<Button>(true);
		foreach (Button val in componentsInChildren)
		{
			if ((Object)(object)val != (Object)null && ((Object)val).name == "VHModpackFixCloseButton" && ((Component)val).transform.IsChildOf((Transform)(object)frame))
			{
				return val;
			}
		}
		return null;
	}

	private static Button FindActiveEpicLootActionButton(Component dialogRoot)
	{
		object obj = FindAncestorComponent((dialogRoot != null) ? dialogRoot.transform.parent : null, _enchantingTableUiType) ?? _enchantingTableUiInstance?.GetValue(null);
		if (obj == null || !(_panelsField?.GetValue(obj) is IEnumerable enumerable) || _mainButtonField == null)
		{
			return null;
		}
		Button val = null;
		foreach (object item in enumerable)
		{
			if (item == null)
			{
				continue;
			}
			object? value = _mainButtonField.GetValue(item);
			Button val2 = (Button)((value is Button) ? value : null);
			if (val2 != null)
			{
				if (val == null)
				{
					val = val2;
				}
				Behaviour val3 = (Behaviour)((item is Behaviour) ? item : null);
				if (val3 != null && val3.isActiveAndEnabled && ((Component)val2).gameObject.activeInHierarchy)
				{
					return val2;
				}
			}
		}
		return val;
	}

	private static Button CloneActionButton(Button template, RectTransform frame)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: 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)
		Transform transform = ((Component)template).transform;
		RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
		? val2;
		if (val == null)
		{
			val2 = new Vector2(180f, 40f);
		}
		else
		{
			Rect rect = val.rect;
			val2 = ((Rect)(ref rect)).size;
		}
		Vector2 val3 = (Vector2)val2;
		Button obj = Object.Instantiate<Button>(template, (Transform)(object)frame);
		((Object)obj).name = "VHModpackFixCloseButton";
		Transform transform2 = ((Component)obj).transform;
		RectTransform val4 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
		if (val4 != null && val3.x > 1f && val3.y > 1f)
		{
			val4.anchorMin = new Vector2(0.5f, 0f);
			val4.anchorMax = new Vector2(0.5f, 0f);
			val4.sizeDelta = val3;
		}
		Transform val5 = ((Component)obj).transform.Find("Hint-1");
		if ((Object)(object)val5 != (Object)null)
		{
			((Component)val5).gameObject.SetActive(false);
		}
		RemoveClonedInputComponent(obj, "UITooltip");
		RemoveClonedInputComponent(obj, "UIInputHandler");
		RemoveClonedInputComponent(obj, "UIGamePad");
		return obj;
	}

	private static void RemoveObsoleteDialogButtons(Component root)
	{
		Button[] componentsInChildren = root.GetComponentsInChildren<Button>(true);
		foreach (Button val in componentsInChildren)
		{
			if (!((Object)(object)val == (Object)null) && !(((Object)val).name == "VHModpackFixCloseButton") && !((Object)(object)((Component)val).GetComponentInParent<Scrollbar>() != (Object)null))
			{
				((Component)val).gameObject.SetActive(false);
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}
	}

	private static void RemoveClonedInputComponent(Button button, string typeName)
	{
		Component component = ((Component)button).GetComponent(typeName);
		if (!((Object)(object)component == (Object)null))
		{
			Behaviour val = (Behaviour)(object)((component is Behaviour) ? component : null);
			if (val != null)
			{
				val.enabled = false;
			}
			Object.Destroy((Object)(object)component);
		}
	}

	private static Component FindAncestorComponent(Transform start, Type componentType)
	{
		if (componentType == null)
		{
			return null;
		}
		Transform val = start;
		while ((Object)(object)val != (Object)null)
		{
			Component component = ((Component)val).GetComponent(componentType);
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			val = val.parent;
		}
		return null;
	}

	internal static string GetDecoratedName(ItemData item)
	{
		if (!(_getDecoratedName != null) || !(((_getDecoratedName.GetParameters().Length == 2) ? _getDecoratedName.Invoke(null, new object[2] { item, null }) : _getDecoratedName.Invoke(null, new object[1] { item })) is string text) || string.IsNullOrEmpty(text))
		{
			return item.m_shared?.m_name ?? string.Empty;
		}
		return text;
	}

	internal static string Localize(string text)
	{
		if (Localization.instance != null)
		{
			return Localization.instance.Localize(text);
		}
		return text;
	}

	private static Transform FindAncestor(Transform transform, string name)
	{
		Transform val = transform;
		while ((Object)(object)val != (Object)null)
		{
			if (string.Equals(((Object)val).name, name, StringComparison.Ordinal))
			{
				return val;
			}
			val = val.parent;
		}
		return null;
	}

	private static T GetFieldValue<T>(FieldInfo field, object instance) where T : class
	{
		return field?.GetValue(instance) as T;
	}
}
internal static class ExpandedDungeonFixes
{
	private sealed class RoomRangeConfig
	{
		internal ConfigEntry<int> Minimum { get; }

		internal ConfigEntry<int> Maximum { get; }

		internal RoomRangeConfig(ConfigEntry<int> minimum, ConfigEntry<int> maximum)
		{
			Minimum = minimum;
			Maximum = maximum;
		}
	}

	private readonly struct RoomTarget
	{
		internal int Minimum { get; }

		internal int Maximum { get; }

		internal RoomTarget(int minimum, int maximum)
		{
			Minimum = minimum;
			Maximum = maximum;
		}
	}

	private readonly struct CampCorrection
	{
		internal int MinimumRooms { get; }

		internal float MinimumRadius { get; }

		internal float MaximumRadius { get; }

		internal CampCorrection(int minimumRooms, float minimumRadius, float maximumRadius)
		{
			MinimumRooms = minimumRooms;
			MinimumRadius = minimumRadius;
			MaximumRadius = maximumRadius;
		}
	}

	private delegate bool PlaceOneRoomDelegate(DungeonGenerator instance, SpawnMode mode);

	internal const string AmazingNatureGuid = "balrond.astafaraios.BalrondAmazingNature";

	private const string JotunnGuid = "com.jotunn.jotunn";

	private const string MoreWorldLocationsGuid = "warpalicious.More_World_Locations_AIO";

	private static readonly HashSet<string> AuthoredDungeonNames = new HashSet<string>(StringComparer.Ordinal) { "DG_DvergrBoss", "DG_Hildir_PlainsFortress" };

	private static readonly Dictionary<string, RoomRangeConfig> NamedRanges = new Dictionary<string, RoomRangeConfig>(StringComparer.Ordinal);

	private static readonly Dictionary<string, RoomTarget> ActiveTargets = new Dictionary<string, RoomTarget>(StringComparer.Ordinal);

	private static readonly Dictionary<string, CampCorrection> AmazingNatureCamps = new Dictionary<string, CampCorrection>(StringComparer.Ordinal)
	{
		["DG_AshlandRuins"] = new CampCorrection(20, 30f, 30f),
		["DG_FortressRuins"] = new CampCorrection(30, 30f, 30f),
		["DG_GoblinCamp"] = new CampCorrection(15, 15f, 30f),
		["DG_MeadowsFarm"] = new CampCorrection(20, 18f, 30f),
		["DG_MeadowsVillage"] = new CampCorrection(20, 28f, 30f)
	};

	private static ConfigEntry<bool> _enabled;

	private static ConfigEntry<int> _verticalZoneSize;

	private static ConfigEntry<int> _attemptMultiplier;

	private static ConfigEntry<int> _consecutiveFailureLimit;

	private static ConfigEntry<bool> _correctAmazingNatureCamps;

	private static RoomRangeConfig _defaultRange;

	private static PlaceOneRoomDelegate _placeOneRoom;

	private static FieldInfo _placedRoomsField;

	private static FieldInfo _openConnectionsField;

	private static bool _initialized;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0139: Expected O, but got Unknown
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Expected O, but got Unknown
		BindConfig(config);
		if (_initialized || harmony == null)
		{
			return;
		}
		MethodInfo methodInfo = AccessTools.Method(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(ExpandedDungeonFixes), "ApplyFinalSettings", (Type[])null, (Type[])null);
		MethodInfo methodInfo3 = AccessTools.Method(typeof(DungeonGenerator), "PlaceRooms", (Type[])null, (Type[])null);
		MethodInfo methodInfo4 = AccessTools.Method(typeof(ExpandedDungeonFixes), "PlaceRoomsPrefix", (Type[])null, (Type[])null);
		MethodInfo methodInfo5 = AccessTools.Method(typeof(DungeonGenerator), "PlaceOneRoom", (Type[])null, (Type[])null);
		FieldInfo fieldInfo = AccessTools.Field(typeof(DungeonGenerator), "m_placedRooms");
		FieldInfo fieldInfo2 = AccessTools.Field(typeof(DungeonGenerator), "m_openConnections");
		if (methodInfo == null || methodInfo2 == null || methodInfo3 == null || methodInfo4 == null || methodInfo5 == null || fieldInfo == null || fieldInfo2 == null || !fieldInfo.IsStatic || !fieldInfo2.IsStatic)
		{
			VHModpackFixPlugin.LogWarning("Expanded dungeon generation was not installed because the required Valheim methods were not found", null);
			return;
		}
		try
		{
			_placeOneRoom = AccessTools.MethodDelegate<PlaceOneRoomDelegate>(methodInfo5, (object)null, true);
			_placedRoomsField = fieldInfo;
			_openConnectionsField = fieldInfo2;
			HarmonyMethod val = new HarmonyMethod(methodInfo2);
			val.priority = 0;
			val.after = new string[3] { "balrond.astafaraios.BalrondAmazingNature", "com.jotunn.jotunn", "warpalicious.More_World_Locations_AIO" };
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val = new HarmonyMethod(methodInfo4);
			val.priority = 0;
			val.after = new string[1] { "warpalicious.More_World_Locations_AIO" };
			harmony.Patch((MethodBase)methodInfo3, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			_initialized = true;
		}
		catch (Exception exception)
		{
			_placeOneRoom = null;
			_placedRoomsField = null;
			_openConnectionsField = null;
			VHModpackFixPlugin.LogWarning("Could not install expanded dungeon generation", exception);
		}
	}

	internal static void Reset()
	{
		ActiveTargets.Clear();
		_initialized = false;
		_placeOneRoom = null;
		_placedRoomsField = null;
		_openConnectionsField = null;
	}

	private static void BindConfig(ConfigFile config)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Expected O, but got Unknown
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Expected O, but got Unknown
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Expected O, but got Unknown
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Expected O, but got Unknown
		_enabled = config.Bind<bool>("Expanded Dungeons - Generation", "Enable expanded procedural dungeons", true, new ConfigDescription("Makes newly generated procedural Dungeon layouts larger. Existing saved roomData is not rebuilt. The option uses no update loop and requires a full Valheim restart after changes.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Order = 1000
			}
		}));
		_verticalZoneSize = config.Bind<int>("Expanded Dungeons - Generation", "Vertical zone size", 256, new ConfigDescription("Minimum vertical generation volume for every Dungeon generator. X/Z remain unchanged at their prefab values.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(64, 512), Array.Empty<object>()));
		_attemptMultiplier = config.Bind<int>("Expanded Dungeons - Generation", "Placement attempt multiplier", 4, new ConfigDescription("Maximum placement attempts per configured maximum main room. Higher values help difficult layouts reach their target but increase one-time generation cost.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), Array.Empty<object>()));
		_consecutiveFailureLimit = config.Bind<int>("Expanded Dungeons - Generation", "Consecutive failed placement limit", 32, new ConfigDescription("Stops a saturated layout after this many consecutive failed room placements.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(8, 256), Array.Empty<object>()));
		_correctAmazingNatureCamps = config.Bind<bool>("Expanded Dungeons - Generation", "Correct Amazing Nature outdoor camps", true, "When Balrond Amazing Nature is present, restores sensible Meadows/Goblin camp minimums, keeps camp radii inside the 64-metre generation zone, and removes unused required-room settings.");
		NamedRanges.Clear();
		_defaultRange = BindRange(config, "Expanded Dungeons - Room Targets", "Other procedural dungeons", 40, 70);
		NamedRanges["DG_Cave"] = BindRange(config, "Expanded Dungeons - Room Targets", "Cave", 30, 75);
		NamedRanges["DG_ForestCrypt"] = BindRange(config, "Expanded Dungeons - Room Targets", "Forest Crypt", 40, 70);
		NamedRanges["DG_SunkenCrypt"] = BindRange(config, "Expanded Dungeons - Room Targets", "Sunken Crypt", 35, 90);
		NamedRanges["DG_DvergrTown"] = BindRange(config, "Expanded Dungeons - Room Targets", "Dvergr Town", 55, 130);
		NamedRanges["DG_Hildir_Cave"] = BindRange(config, "Expanded Dungeons - Room Targets", "Hildir Cave", 65, 80);
		NamedRanges["DG_Hildir_ForestCrypt"] = BindRange(config, "Expanded Dungeons - Room Targets", "Hildir Forest Crypt", 40, 55);
		NamedRanges["DG_BlackForestDungeon"] = BindRange(config, "Expanded Dungeons - Room Targets", "MWL Black Forest Dungeon", 50, 90);
		NamedRanges["DG_CatacombDungeon"] = BindRange(config, "Expanded Dungeons - Room Targets", "MWL Catacomb Dungeon", 60, 90);
	}

	private static RoomRangeConfig BindRange(ConfigFile config, string section, string displayName, int defaultMinimum, int defaultMaximum)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Expected O, but got Unknown
		ConfigEntry<int> minimum = config.Bind<int>(section, displayName + " minimum main rooms", defaultMinimum, new ConfigDescription("Minimum target before end caps for " + displayName + ".", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 256), Array.Empty<object>()));
		ConfigEntry<int> maximum = config.Bind<int>(section, displayName + " maximum main rooms", defaultMaximum, new ConfigDescription("Maximum target before end caps for " + displayName + ". Must be at least its minimum.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 256), Array.Empty<object>()));
		return new RoomRangeConfig(minimum, maximum);
	}

	private static void ApplyFinalSettings(ZNetScene __instance)
	{
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0182: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: Invalid comparison between Unknown and I4
		ActiveTargets.Clear();
		ConfigEntry<bool> enabled = _enabled;
		if (enabled == null || !enabled.Value)
		{
			VHModpackFixPlugin.LogInfo("Expanded dungeons final: disabled");
			return;
		}
		if (__instance?.m_prefabs == null)
		{
			VHModpackFixPlugin.LogInfo("Expanded dungeons final: prefab registry unavailable");
			return;
		}
		bool flag = Chainloader.PluginInfos.ContainsKey("balrond.astafaraios.BalrondAmazingNature");
		SortedDictionary<string, string> sortedDictionary = new SortedDictionary<string, string>(StringComparer.Ordinal);
		HashSet<DungeonGenerator> hashSet = new HashSet<DungeonGenerator>();
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		foreach (GameObject prefab in __instance.m_prefabs)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				continue;
			}
			DungeonGenerator[] componentsInChildren = prefab.GetComponentsInChildren<DungeonGenerator>(true);
			foreach (DungeonGenerator val in componentsInChildren)
			{
				if (!Object.op_Implicit((Object)(object)val) || !hashSet.Add(val))
				{
					continue;
				}
				string text = ResolveGeneratorName(((Component)val).gameObject, prefab);
				if ((int)val.m_algorithm == 0)
				{
					SetVerticalSize(val);
					val.m_campRadiusMin = 0f;
					val.m_campRadiusMax = 0f;
					NormalizeRequiredRooms(val);
					if (AuthoredDungeonNames.Contains(text))
					{
						num2++;
					}
					else
					{
						RoomTarget value = ResolveTarget(text, val);
						val.m_minRooms = value.Minimum;
						val.m_maxRooms = value.Maximum;
						ActiveTargets[text] = value;
						num++;
					}
					sortedDictionary[text] = FormatSettings(text, val);
				}
				else if (flag)
				{
					ConfigEntry<bool> correctAmazingNatureCamps = _correctAmazingNatureCamps;
					if (correctAmazingNatureCamps != null && correctAmazingNatureCamps.Value && (int)val.m_algorithm == 2 && ApplyCampCorrection(text, val))
					{
						num3++;
						sortedDictionary[text] = FormatSettings(text, val);
					}
				}
			}
		}
		string text2 = (flag ? "present" : "absent");
		string text3 = string.Join("; ", sortedDictionary.Values);
		VHModpackFixPlugin.LogInfo($"Expanded dungeons final: AmazingNature={text2}, targets={num}, authored={num2}, camps={num3} | {text3}");
	}

	private static bool PlaceRoomsPrefix(DungeonGenerator __instance, SpawnMode mode)
	{
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		ConfigEntry<bool> enabled = _enabled;
		if (enabled == null || !enabled.Value || (Object)(object)__instance == (Object)null || _placeOneRoom == null || _placedRoomsField == null || _openConnectionsField == null)
		{
			return true;
		}
		string text = ResolveGeneratorName(((Component)__instance).gameObject, null);
		if (string.IsNullOrEmpty(text) || !ActiveTargets.TryGetValue(text, out var value))
		{
			return true;
		}
		List<Room> list = _placedRoomsField.GetValue(null) as List<Room>;
		List<RoomConnection> list2 = _openConnectionsField.GetValue(null) as List<RoomConnection>;
		if (list == null || list2 == null)
		{
			return true;
		}
		int num = Random.Range(value.Minimum, value.Maximum + 1);
		int num2 = Math.Max(value.Maximum, value.Maximum * (_attemptMultiplier?.Value ?? 4));
		int num3 = _consecutiveFailureLimit?.Value ?? 32;
		int num4 = 0;
		for (int i = 0; i < num2; i++)
		{
			if (list2.Count == 0)
			{
				break;
			}
			if (list.Count >= value.Maximum)
			{
				break;
			}
			if (_placeOneRoom(__instance, mode))
			{
				num4 = 0;
			}
			else if (++num4 >= num3)
			{
				break;
			}
			if (list.Count >= num && RequiredRoomsSatisfied(__instance, list))
			{
				break;
			}
		}
		return false;
	}

	private static RoomTarget ResolveTarget(string generatorName, DungeonGenerator generator)
	{
		RoomRangeConfig value;
		bool num = NamedRanges.TryGetValue(generatorName, out value);
		if (value == null)
		{
			value = _defaultRange;
		}
		int num2 = Math.Max(1, value.Minimum.Value);
		int num3 = Math.Max(num2, value.Maximum.Value);
		if (!num)
		{
			num2 = Math.Max(num2, generator.m_minRooms);
			num3 = Math.Max(num3, generator.m_maxRooms);
			num3 = Math.Max(num2, num3);
		}
		return new RoomTarget(num2, num3);
	}

	private static void SetVerticalSize(DungeonGenerator generator)
	{
		//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_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		Vector3 zoneSize = generator.m_zoneSize;
		zoneSize.y = Math.Max(zoneSize.y, _verticalZoneSize?.Value ?? 256);
		generator.m_zoneSize = zoneSize;
	}

	private static void NormalizeRequiredRooms(DungeonGenerator generator)
	{
		int num = generator.m_requiredRooms?.Count ?? 0;
		generator.m_minRequiredRooms = ((num != 0) ? Mathf.Clamp(generator.m_minRequiredRooms, 1, num) : 0);
	}

	private static bool RequiredRoomsSatisfied(DungeonGenerator generator, List<Room> placedRooms)
	{
		if (generator.m_minRequiredRooms <= 0 || generator.m_requiredRooms == null || generator.m_requiredRooms.Count == 0)
		{
			return true;
		}
		int num = 0;
		foreach (Room placedRoom in placedRooms)
		{
			if (Object.op_Implicit((Object)(object)placedRoom) && generator.m_requiredRooms.Contains(((Object)((Component)placedRoom).gameObject).name))
			{
				num++;
			}
		}
		return num >= generator.m_minRequiredRooms;
	}

	private static bool ApplyCampCorrection(string generatorName, DungeonGenerator generator)
	{
		if (!AmazingNatureCamps.TryGetValue(generatorName, out var value))
		{
			return false;
		}
		float val = Math.Max(0f, Math.Min(generator.m_zoneSize.x, generator.m_zoneSize.z) * 0.5f - 2f);
		float val2 = Math.Min(value.MinimumRadius, val);
		float val3 = Math.Min(value.MaximumRadius, val);
		generator.m_minRooms = Math.Max(generator.m_minRooms, value.MinimumRooms);
		generator.m_maxRooms = Math.Max(generator.m_minRooms, generator.m_maxRooms);
		generator.m_minRequiredRooms = 0;
		generator.m_campRadiusMin = Math.Min(val2, val3);
		generator.m_campRadiusMax = Math.Max(val2, val3);
		return true;
	}

	private static string ResolveGeneratorName(GameObject generatorObject, GameObject rootPrefab)
	{
		string result = string.Empty;
		Transform val = (Object.op_Implicit((Object)(object)generatorObject) ? generatorObject.transform : null);
		while (Object.op_Implicit((Object)(object)val))
		{
			string prefabName = Utils.GetPrefabName(((Component)val).gameObject);
			if (!string.IsNullOrEmpty(prefabName))
			{
				result = prefabName;
				if (IsKnownGeneratorName(prefabName))
				{
					return prefabName;
				}
			}
			val = val.parent;
		}
		string text = (Object.op_Implicit((Object)(object)rootPrefab) ? Utils.GetPrefabName(rootPrefab) : string.Empty);
		if (!string.IsNullOrEmpty(text))
		{
			return text;
		}
		return result;
	}

	private static bool IsKnownGeneratorName(string generatorName)
	{
		if (!NamedRanges.ContainsKey(generatorName) && !AmazingNatureCamps.ContainsKey(generatorName) && !AuthoredDungeonNames.Contains(generatorName))
		{
			return generatorName.StartsWith("DG_", StringComparison.Ordinal);
		}
		return true;
	}

	private static string FormatSettings(string generatorName, DungeonGenerator generator)
	{
		//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_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: 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)
		Vector3 zoneSize = generator.m_zoneSize;
		int num = generator.m_requiredRooms?.Count ?? 0;
		return string.Format(CultureInfo.InvariantCulture, "{0}[{1},rooms={2}-{3},required={4}/{5},radius={6:0.#}-{7:0.#},zone={8:0.#}x{9:0.#}x{10:0.#}]", generatorName, generator.m_algorithm, generator.m_minRooms, generator.m_maxRooms, generator.m_minRequiredRooms, num, generator.m_campRadiusMin, generator.m_campRadiusMax, zoneSize.x, zoneSize.y, zoneSize.z);
	}
}
internal static class InventorySlotsAutoSort
{
	private const string InventorySlotsGuid = "sighsorry.InventorySlots";

	private const string InventorySlotsPluginType = "InventorySlots.InventorySlotsPlugin";

	private static ConfigEntry<bool> _sortPlayerInventory;

	private static ConfigEntry<bool> _sortOpenedContainer;

	private static MethodInfo _sortPlayerInventoryMethod;

	private static MethodInfo _sortCurrentContainerMethod;

	private static FieldInfo _currentContainerField;

	private static bool _initialized;

	private static bool _methodsResolved;

	private static bool _unavailableWarningLogged;

	private static bool _playerSortWarningLogged;

	private static bool _containerSortWarningLogged;

	private static int _lastPlayerSortFrame = -1;

	private static int _lastContainerSortFrame = -1;

	private static int _lastContainerInstanceId;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Expected O, but got Unknown
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Expected O, but got Unknown
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Expected O, but got Unknown
		if (!_initialized)
		{
			_initialized = true;
			_sortPlayerInventory = config.Bind<bool>("Inventory Auto-Sort", "Auto-sort player inventory on open", false, new ConfigDescription("Automatically tidies your inventory and combines matching partial stacks whenever the inventory window is opened. Favorite and protected slots stay untouched. Requires InventorySlots.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 200
				}
			}));
			_sortOpenedContainer = config.Bind<bool>("Inventory Auto-Sort", "Auto-sort opened container on open", false, new ConfigDescription("Automatically tidies the chest, backpack, or other container you open and combines matching partial stacks. Requires InventorySlots.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = 100
				}
			}));
			_currentContainerField = AccessTools.Field(typeof(InventoryGui), "m_currentContainer");
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryGui), "Show", new Type[2]
			{
				typeof(Container),
				typeof(int)
			}, (Type[])null);
			if (methodInfo == null)
			{
				VHModpackFixPlugin.LogWarning("Inventory auto-sort was not installed because InventoryGui.Show(Container, int) could not be found", null);
				return;
			}
			HarmonyMethod val = new HarmonyMethod(typeof(InventorySlotsAutoSort), "AfterShow", (Type[])null);
			val.priority = 0;
			val.after = new string[2] { "sighsorry.InventorySlots", "vapok.mods.adventurebackpacks" };
			HarmonyMethod val2 = val;
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}

	private static void AfterShow(InventoryGui __instance, Container container)
	{
		ConfigEntry<bool> sortPlayerInventory = _sortPlayerInventory;
		if (sortPlayerInventory == null || !sortPlayerInventory.Value)
		{
			ConfigEntry<bool> sortOpenedContainer = _sortOpenedContainer;
			if (sortOpenedContainer == null || !sortOpenedContainer.Value)
			{
				return;
			}
		}
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null || (Object)(object)__instance == (Object)null || !TryResolveInventorySlotsMethods())
		{
			return;
		}
		if (_sortPlayerInventory.Value && _sortPlayerInventoryMethod != null && _lastPlayerSortFrame != Time.frameCount)
		{
			_lastPlayerSortFrame = Time.frameCount;
			if (!InvokeSort(_sortPlayerInventoryMethod, localPlayer, "player inventory", ref _playerSortWarningLogged))
			{
				_sortPlayerInventoryMethod = null;
			}
		}
		object? obj = _currentContainerField?.GetValue(__instance);
		Container val = (Container)(((obj is Container) ? obj : null) ?? container);
		int num = ((!((Object)(object)val == (Object)null)) ? ((Object)val).GetInstanceID() : 0);
		bool flag = _lastContainerSortFrame == Time.frameCount && _lastContainerInstanceId == num;
		if (_sortOpenedContainer.Value && _sortCurrentContainerMethod != null && (Object)(object)val != (Object)null && __instance.IsContainerOpen() && !flag)
		{
			_lastContainerSortFrame = Time.frameCount;
			_lastContainerInstanceId = num;
			if (!InvokeSort(_sortCurrentContainerMethod, localPlayer, "opened container", ref _containerSortWarningLogged))
			{
				_sortCurrentContainerMethod = null;
			}
		}
	}

	private static bool TryResolveInventorySlotsMethods()
	{
		if (_methodsResolved)
		{
			if (!(_sortPlayerInventoryMethod != null))
			{
				return _sortCurrentContainerMethod != null;
			}
			return true;
		}
		_methodsResolved = true;
		if (!Chainloader.PluginInfos.ContainsKey("sighsorry.InventorySlots"))
		{
			LogUnavailableWarning("InventorySlots is not loaded");
			return false;
		}
		Type type = AccessTools.TypeByName("InventorySlots.InventorySlotsPlugin");
		if (type == null)
		{
			LogUnavailableWarning("the InventorySlots plugin type could not be found");
			return false;
		}
		_sortPlayerInventoryMethod = AccessTools.Method(type, "SortPlayerInventory", new Type[1] { typeof(Player) }, (Type[])null);
		_sortCurrentContainerMethod = AccessTools.Method(type, "SortCurrentContainer", new Type[1] { typeof(Player) }, (Type[])null);
		if (_sortPlayerInventoryMethod == null && _sortCurrentContainerMethod == null)
		{
			LogUnavailableWarning("this InventorySlots version does not expose the expected sorting methods");
			return false;
		}
		return true;
	}

	private static bool InvokeSort(MethodInfo method, Player player, string target, ref bool warningLogged)
	{
		try
		{
			method.Invoke(null, new object[1] { player });
			return true;
		}
		catch (Exception ex)
		{
			if (!warningLogged)
			{
				warningLogged = true;
				Exception exception = ((ex is TargetInvocationException && ex.InnerException != null) ? ex.InnerException : ex);
				VHModpackFixPlugin.LogWarning("InventorySlots could not auto-sort the " + target, exception);
			}
			return false;
		}
	}

	private static void LogUnavailableWarning(string reason)
	{
		if (!_unavailableWarningLogged)
		{
			_unavailableWarningLogged = true;
			VHModpackFixPlugin.LogWarning("Inventory auto-sort is enabled, but " + reason, null);
		}
	}
}
internal static class MoreWorldLocationsFixes
{
	private const string JotunnGuid = "com.jotunn.jotunn";

	private const string MoreWorldLocationsGuid = "warpalicious.More_World_Locations_AIO";

	private const string MountainLocationName = "MWL_MountainCultShrine1";

	private const string ForestLocationName = "MWL_ForestSkull1";

	private const string BrokenMountainMock = "JVLmock_stone_pi";

	private const string FixedMountainMock = "JVLmock_stone_pillar";

	private const string DoubleMockPrefix = "JVLmock_JVLmock_";

	private const string MockPrefix = "JVLmock_";

	private static ConfigEntry<bool> _enabled;

	private static bool _initialized;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Expected O, but got Unknown
		if (_initialized)
		{
			return;
		}
		_initialized = true;
		_enabled = ConfigLayout.Bind(config, "More World Locations", "Repair broken location mocks", defaultValue: true, "Repairs invalid Jotunn mock names in MWL_MountainCultShrine1 and MWL_ForestSkull1 before those location assets are activated. This prevents their unresolved network pieces from creating invalid ZDOs and later ZNetScene.RemoveObjects errors. The option changes no save format and requires a full Valheim restart to take effect.", "More World Locations compatibility");
		if (!Chainloader.PluginInfos.ContainsKey("com.jotunn.jotunn") || !Chainloader.PluginInfos.ContainsKey("warpalicious.More_World_Locations_AIO"))
		{
			return;
		}
		Type type = AccessTools.TypeByName("Jotunn.PrefabExtension");
		MethodInfo methodInfo = ((type == null) ? null : AccessTools.Method(type, "FixReferences", new Type[2]
		{
			typeof(GameObject),
			typeof(bool)
		}, (Type[])null));
		MethodInfo methodInfo2 = AccessTools.Method(typeof(MoreWorldLocationsFixes), "BeforeFixReferences", (Type[])null, (Type[])null);
		if (methodInfo == null || methodInfo2 == null)
		{
			VHModpackFixPlugin.LogWarning("More World Locations mock repair was not installed because Jotunn.PrefabExtension.FixReferences(GameObject, bool) could not be found", null);
			return;
		}
		try
		{
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2)
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			VHModpackFixPlugin.LogInfo("More World Locations mock repair installed.");
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("Could not install More World Locations mock repair", exception);
		}
	}

	private static void BeforeFixReferences(GameObject __0, bool __1)
	{
		ConfigEntry<bool> enabled = _enabled;
		if (enabled == null || !enabled.Value || !__1 || !Object.op_Implicit((Object)(object)__0))
		{
			return;
		}
		string name = ((Object)__0).name;
		if (!string.Equals(name, "MWL_MountainCultShrine1", StringComparison.Ordinal) && !string.Equals(name, "MWL_ForestSkull1", StringComparison.Ordinal))
		{
			return;
		}
		Transform[] componentsInChildren = __0.GetComponentsInChildren<Transform>(true);
		int num = 0;
		if (string.Equals(name, "MWL_MountainCultShrine1", StringComparison.Ordinal))
		{
			foreach (Transform val in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)val) && string.Equals(((Object)val).name, "JVLmock_stone_pi", StringComparison.Ordinal))
				{
					((Object)val).name = "JVLmock_stone_pillar";
					num++;
				}
			}
		}
		else
		{
			foreach (Transform val2 in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)val2))
				{
					string name2 = ((Object)val2).name;
					if (name2.StartsWith("JVLmock_JVLmock_", StringComparison.Ordinal))
					{
						((Object)val2).name = name2.Substring("JVLmock_".Length);
						num++;
					}
				}
			}
		}
		if (num > 0)
		{
			VHModpackFixPlugin.LogInfo($"Repaired {num} invalid More World Locations mock reference(s) in {name} before Jotunn resolution.");
		}
	}
}
internal static class SunkenCryptRoomHierarchyFixes
{
	private const string RoomPrefabName = "sunkencrypt_new_Room4";

	private const string NestedConnectionPath = "Room/Connection (2)";

	private static ConfigEntry<bool> _enabled;

	private static bool _initialized;

	private static bool _repairLogged;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//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_008d: Expected O, but got Unknown
		_enabled = ConfigLayout.Bind(config, "Sunken Crypt", "Vanilla SunkenCrypt Room4 hierarchy", defaultValue: true, "Moves the misplaced Room4 dungeon connection to the prefab root before Valheim caches room connections.", "Fixes");
		if (!_initialized && harmony != null)
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(Room), "GetConnections", Type.EmptyTypes, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(SunkenCryptRoomHierarchyFixes), "GetConnectionsPrefix", (Type[])null, (Type[])null);
			if (!(methodInfo == null) && !(methodInfo2 == null))
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2)
				{
					priority = 800
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_initialized = true;
			}
		}
	}

	private static void GetConnectionsPrefix(Room __instance)
	{
		ConfigEntry<bool> enabled = _enabled;
		if (enabled == null || !enabled.Value || (Object)(object)__instance == (Object)null)
		{
			return;
		}
		GameObject gameObject = ((Component)__instance).gameObject;
		if ((Object)(object)gameObject == (Object)null || !string.Equals(Utils.GetPrefabName(gameObject), "sunkencrypt_new_Room4", StringComparison.Ordinal))
		{
			return;
		}
		Transform transform = ((Component)__instance).transform;
		Transform val = transform.Find("Room/Connection (2)");
		if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).GetComponent<RoomConnection>() == (Object)null))
		{
			val.SetParent(transform, true);
			if (!_repairLogged)
			{
				_repairLogged = true;
				VHModpackFixPlugin.LogInfo("Reparented the misplaced sunkencrypt_new_Room4 Connection (2)");
			}
		}
	}
}
[BepInPlugin("obelisk.vhmodpackfix", "VHModpackFix", "1.1.24")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class VHModpackFixPlugin : BaseUnityPlugin
{
	public const string PluginGuid = "obelisk.vhmodpackfix";

	public const string PluginName = "VHModpackFix";

	public const string PluginVersion = "1.1.24";

	private static readonly Harmony Harmony = new Harmony("obelisk.vhmodpackfix");

	private static ManualLogSource _log;

	private ConfigEntry<bool> _enableEpicLootFixes;

	private void Awake()
	{
		_log = ((BaseUnityPlugin)this).Logger;
		bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
		((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
		ConfigLayout.Begin(((BaseUnityPlugin)this).Config);
		try
		{
			AAABuildMenuLifecycleFixes.Init(Harmony, ((BaseUnityPlugin)this).Config);
			AdventureBackpacksAutoStoreCompat.Init(Harmony, ((BaseUnityPlugin)this).Config);
			AdventureBackpacksContainerPanel.Init(Harmony, ((BaseUnityPlugin)this).Config);
			AzuAutoStoreLogFixes.Init(Harmony, ((BaseUnityPlugin)this).Config);
			AzuCraftyBoxesContainerSafety.Init(Harmony, ((BaseUnityPlugin)this).Config);
			BalrondArsenalVisualFixes.Bind(((BaseUnityPlugin)this).Config);
			BossAddNetworkVfxFixes.Init(Harmony, ((BaseUnityPlugin)this).Config);
			BowFixes.Bind(((BaseUnityPlugin)this).Config);
			ContainerLootSafetyFixes.Init(Harmony, ((BaseUnityPlugin)this).Config);
			_enableEpicLootFixes = ConfigLayout.Bind(((BaseUnityPlugin)this).Config, "Epic Loot", "Enable EpicLoot fixes", defaultValue: true, "Master switch for the Epic Loot UI and resource-count fixes.", "Global Fix Switches");
			EpicLootUiFixes.Init(Harmony, ((BaseUnityPlugin)this).Config, _enableEpicLootFixes);
			EpicLootAugmentChoiceFixes.Init(Harmony, ((BaseUnityPlugin)this).Config, _enableEpicLootFixes);
			EpicLootCraftyBoxesCounts.Init(Harmony, ((BaseUnityPlugin)this).Config, _enableEpicLootFixes);
			ExpandedDungeonFixes.Init(Harmony, ((BaseUnityPlugin)this).Config);
			InventorySlotsAutoSort.Init(Harmony, ((BaseUnityPlugin)this).Config);
			MoreWorldLocationsFixes.Init(Harmony, ((BaseUnityPlugin)this).Config);
			ZNetSceneRegistrySafety.Init(Harmony, ((BaseUnityPlugin)this).Config);
			SunkenCryptRoomHierarchyFixes.Init(Harmony, ((BaseUnityPlugin)this).Config);
			DemisterFixes.Bind(((BaseUnityPlugin)this).Config);
			Harmony.PatchAll(typeof(VHModpackFixPlugin).Assembly);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"VHModpackFix 1.1.24 loaded");
		}
		finally
		{
			try
			{
				ConfigLayout.RemoveRetiredEntries(((BaseUnityPlugin)this).Config);
				((BaseUnityPlugin)this).Config.Save();
			}
			finally
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
			}
		}
	}

	private void OnDestroy()
	{
		BowFixes.Reset();
		DemisterFixes.Reset();
		ZNetSceneRegistrySafety.Reset();
		ExpandedDungeonFixes.Reset();
		Harmony.UnpatchSelf();
		_log = null;
	}

	internal static void LogWarning(string message, Exception exception)
	{
		ManualLogSource log = _log;
		if (log != null)
		{
			log.LogWarning((object)((exception == null) ? message : (message + ": " + exception.Message)));
		}
	}

	internal static void LogInfo(string message)
	{
		ManualLogSource log = _log;
		if (log != null)
		{
			log.LogInfo((object)message);
		}
	}
}
internal static class ZNetSceneRegistrySafety
{
	private readonly struct PendingDestroyedView
	{
		internal readonly ZNetScene Scene;

		internal readonly ZDO Zdo;

		internal readonly ZNetView View;

		internal readonly string ObjectName;

		internal PendingDestroyedView(ZNetScene scene, ZDO zdo, ZNetView view, string objectName)
		{
			Scene = scene;
			Zdo = zdo;
			View = view;
			ObjectName = objectName;
		}
	}

	private static readonly List<PendingDestroyedView> Pending = new List<PendingDestroyedView>(8);

	private static readonly List<ZDO> StaleKeys = new List<ZDO>(8);

	private static ConfigEntry<bool> _enabled;

	private static bool _initialized;

	private static int _diagnosticMessagesRemaining = 5;

	internal static void Init(Harmony harmony, ConfigFile config)
	{
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Expected O, but got Unknown
		//IL_00dd: Expected O, but got Unknown
		//IL_0111: 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_012a: Expected O, but got Unknown
		if (_initialized)
		{
			return;
		}
		_initialized = true;
		_enabled = ConfigLayout.Bind(config, "Network Cleanup", "Recover stale ZNetScene entries", defaultValue: true, "Prevents a mod that destroys a live ZNetView outside Valheim's network lifecycle from leaving a stale ZNetScene registry entry. Healthy play gets no registry scan. A complete registry scan is used only after vanilla RemoveObjects has already thrown a null-reference error, and the original first error is still reported instead of being hidden.", "Network cleanup safety");
		MethodInfo methodInfo = AccessTools.Method(typeof(ZNetScene), "RemoveObjects", new Type[2]
		{
			typeof(List<ZDO>),
			typeof(List<ZDO>)
		}, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(ZNetView), "OnDestroy", (Type[])null, (Type[])null);
		if (methodInfo == null)
		{
			VHModpackFixPlugin.LogWarning("ZNetScene registry safety was not installed because ZNetScene.RemoveObjects(List<ZDO>, List<ZDO>) could not be found", null);
			return;
		}
		try
		{
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(ZNetSceneRegistrySafety), "BeforeRemoveObjects", (Type[])null, (Type[])null))
			{
				priority = 800
			}, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ZNetSceneRegistrySafety), "AfterRemoveObjectsException", (Type[])null, (Type[])null)), (HarmonyMethod)null);
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("Could not install the ZNetScene registry fallback", exception);
			return;
		}
		bool flag = false;
		if (methodInfo2 != null)
		{
			try
			{
				harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(AccessTools.Method(typeof(ZNetSceneRegistrySafety), "BeforeZNetViewDestroyed", (Type[])null, (Type[])null))
				{
					priority = 800
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				flag = true;
			}
			catch (Exception exception2)
			{
				VHModpackFixPlugin.LogWarning("The proactive ZNetView destruction guard could not be installed; exception-only recovery remains active", exception2);
			}
		}
		VHModpackFixPlugin.LogInfo(flag ? "ZNetScene registry safety installed with proactive and exception-only recovery." : "ZNetScene registry safety installed with exception-only recovery.");
	}

	internal static void Reset()
	{
		Pending.Clear();
		StaleKeys.Clear();
	}

	private static void BeforeZNetViewDestroyed(ZNetView __instance)
	{
		ConfigEntry<bool> enabled = _enabled;
		if (enabled == null || !enabled.Value || __instance == null)
		{
			return;
		}
		ZDO zDO = __instance.GetZDO();
		ZNetScene instance = ZNetScene.instance;
		if (zDO != null && Object.op_Implicit((Object)(object)instance))
		{
			string objectName;
			try
			{
				objectName = ((Object)((Component)__instance).gameObject).name;
			}
			catch (MissingReferenceException)
			{
				objectName = "<destroyed object>";
			}
			Pending.Add(new PendingDestroyedView(instance, zDO, __instance, objectName));
		}
	}

	private static void BeforeRemoveObjects(ZNetScene __instance, List<ZDO> __0, List<ZDO> __1, Dictionary<ZDO, ZNetView> ___m_instances)
	{
		ConfigEntry<bool> enabled = _enabled;
		if (enabled == null || !enabled.Value)
		{
			Pending.Clear();
		}
		else
		{
			if (Pending.Count == 0)
			{
				return;
			}
			if (___m_instances == null || __0 == null || __1 == null)
			{
				Pending.Clear();
				return;
			}
			int num = 0;
			PendingDestroyedView first = default(PendingDestroyedView);
			try
			{
				for (int i = 0; i < Pending.Count; i++)
				{
					PendingDestroyedView pendingDestroyedView = Pending[i];
					if (pendingDestroyedView.Scene == __instance && pendingDestroyedView.Zdo != null && ___m_instances.TryGetValue(pendingDestroyedView.Zdo, out var value) && value == pendingDestroyedView.View && ___m_instances.Remove(pendingDestroyedView.Zdo))
					{
						if (num == 0)
						{
							first = pendingDestroyedView;
						}
						num++;
						RecoverZdo(pendingDestroyedView.Zdo, __0, __1);
					}
				}
			}
			catch (Exception exception)
			{
				VHModpackFixPlugin.LogWarning("Could not process pending stale ZNetScene entries", exception);
			}
			finally
			{
				Pending.Clear();
			}
			if (num > 0)
			{
				LogProactiveRecovery(num, first);
			}
		}
	}

	private static Exception AfterRemoveObjectsException(Exception __exception, ZNetScene __instance, List<ZDO> __0, List<ZDO> __1, Dictionary<ZDO, ZNetView> ___m_instances)
	{
		ConfigEntry<bool> enabled = _enabled;
		if (enabled == null || !enabled.Value || __exception == null || (!(__exception is NullReferenceException) && !(__exception is MissingReferenceException)) || ___m_instances == null || __0 == null || __1 == null)
		{
			return __exception;
		}
		int num = 0;
		ZDO val = null;
		try
		{
			StaleKeys.Clear();
			foreach (KeyValuePair<ZDO, ZNetView> ___m_instance in ___m_instances)
			{
				if (IsStale(___m_instance.Key, ___m_instance.Value))
				{
					StaleKeys.Add(___m_instance.Key);
				}
			}
			for (int i = 0; i < StaleKeys.Count; i++)
			{
				ZDO val2 = StaleKeys[i];
				if (___m_instances.TryGetValue(val2, out var value) && IsStale(val2, value) && ___m_instances.Remove(val2))
				{
					if (val == null)
					{
						val = val2;
					}
					num++;
					RecoverZdo(val2, __0, __1);
				}
			}
		}
		catch (Exception exception)
		{
			VHModpackFixPlugin.LogWarning("Could not repair stale ZNetScene entries", exception);
		}
		finally
		{
			StaleKeys.Clear();
		}
		if (num > 0)
		{
			VHModpackFixPlugin.LogWarning(string.Format("Repaired {0} proven stale ZNetScene registry entr{1} after ", num, (num == 1) ? "y" : "ies") + __exception.GetType().Name + "; " + DescribeZdo(__instance, val, null) + ". The original exception is intentionally preserved, but this entry should not repeat.", null);
		}
		return __exception;
	}

	private static bool IsStale(ZDO key, ZNetView view)
	{
		if (view == null || !Object.op_Implicit((Object)(object)view))
		{
			return true;
		}
		ZDO zDO = view.GetZDO();
		if (zDO != null)
		{
			return zDO != key;
		}
		return true;
	}

	private static void RecoverZdo(ZDO zdo, List<ZDO> currentNearObjects, List<ZDO> currentDistantObjects)
	{
		if (zdo != null && zdo.IsValid())
		{
			zdo.Created = false;
			if (!zdo.Persistent && zdo.IsOwner() && !currentNearObjects.Contains(zdo) && !currentDistantObjects.Contains(zdo) && ZDOMan.instance != null)
			{
				ZDOMan.instance.DestroyZDO(zdo);
			}
		}
	}

	private static void LogProactiveRecovery(int recovered, PendingDestroyedView first)
	{
		if (_diagnosticMessagesRemaining > 0)
		{
			_diagnosticMessagesRemaining--;
			string text = ((_diagnosticMessagesRemaining == 0) ? " Further proactive recovery messages will be suppressed for this session." : string.Empty);
			VHModpackFixPlugin.LogWarning(string.Format("Prevented {0} stale ZNetScene registry entr{1} after a mod destroyed ", recovered, (recovered == 1) ? "y" : "ies") + "a live ZNetView outside Valheim's network lifecycle. " + DescribeZdo(first.Scene, first.Zdo, first.ObjectName) + "." + text, null);
		}
	}

	private static string DescribeZdo(ZNetScene scene, ZDO zdo, string objectName)
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null)
		{
			return "ZDO is unavailable";
		}
		int prefab = zdo.GetPrefab();
		string text = objectName;
		if (string.IsNullOrEmpty(text) && Object.op_Implicit((Object)(object)scene))
		{
			GameObject prefab2 = scene.GetPrefab(prefab);
			if (Object.op_Implicit((Object)(object)prefab2))
			{
				text = ((Object)prefab2).name;
			}
		}
		if (string.IsNullOrEmpty(text))
		{
			text = "<unregistered prefab>";
		}
		return $"First object='{text}', prefabHash={prefab}, zdo={zdo.m_uid}";
	}
}