using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Codex.BossLootOneShot;

[BepInPlugin("codex.bosslootoneshot", "Boss Loot One Shot", "1.0.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
	[HarmonyPatch(typeof(Ragdoll), "SpawnLoot")]
	private static class RagdollSpawnLootPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Ragdoll __instance)
		{
			suppressCurrentSpawnLoot = false;
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return true;
			}
			if (!component.IsOwner())
			{
				suppressCurrentSpawnLoot = true;
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return true;
			}
			if (zDO.GetBool("codex_ragdoll_loot_processed", false))
			{
				suppressCurrentSpawnLoot = true;
				return false;
			}
			zDO.Set("codex_ragdoll_loot_processed", true);
			return true;
		}

		[HarmonyFinalizer]
		private static Exception Finalizer(Exception __exception)
		{
			suppressCurrentSpawnLoot = false;
			return __exception;
		}
	}

	private const string LootProcessedKey = "codex_ragdoll_loot_processed";

	[ThreadStatic]
	private static bool suppressCurrentSpawnLoot;

	private Harmony harmony;

	private bool epicLootPatched;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		harmony = new Harmony("codex.bosslootoneshot");
		harmony.PatchAll(typeof(Plugin).Assembly);
		PatchEpicLootCallback();
	}

	private void Start()
	{
		PatchEpicLootCallback();
	}

	private void PatchEpicLootCallback()
	{
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Expected O, but got Unknown
		if (!epicLootPatched)
		{
			Type type = AccessTools.TypeByName("EpicLoot.Ragdoll_SpawnLoot_Patch");
			MethodInfo methodInfo = ((type != null) ? AccessTools.Method(type, "Postfix", (Type[])null, (Type[])null) : null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Plugin), "GuardEpicLootCallback", (Type[])null, (Type[])null);
			if (methodInfo != null && methodInfo2 != null)
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				epicLootPatched = true;
				((BaseUnityPlugin)this).Logger.LogInfo((object)"EpicLoot ragdoll loot callback is protected against repeated SpawnLoot calls.");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"EpicLoot ragdoll loot callback was not found; vanilla ragdoll one-shot protection remains active.");
			}
		}
	}

	private static bool GuardEpicLootCallback()
	{
		return !suppressCurrentSpawnLoot;
	}
}

using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Codex.CreatureStarDamageCurve;

[BepInPlugin("codex.creaturestardamagecurve", "Creature Star Damage Curve", "1.0.2")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
	private void Awake()
	{
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Expected O, but got Unknown
		MethodInfo methodInfo = AccessTools.Method(AccessTools.TypeByName("CreatureManager.CreatureLevelManager"), "TrySelectDamageMultiplier", (Type[])null, (Type[])null);
		if (methodInfo == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"CreatureManager damage method was not found; star damage curve was not applied.");
			return;
		}
		new Harmony("codex.creaturestardamagecurve").Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin).GetMethod("ApplyDamageCurve", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Creature star damage scaling is linear: +100% base damage per star.");
	}

	private static void ApplyDamageCurve(Character character, ref float multiplier)
	{
		if (!((Object)(object)character == (Object)null) && !character.IsPlayer() && !(multiplier <= 0f))
		{
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Codex.EnforcerBossProgression;

[BepInPlugin("codex.enforcerbossprogression", "Enforcer Boss Progression", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
	private sealed class RemovedCandidate
	{
		internal int Index;

		internal object Value;
	}

	private static readonly Dictionary<string, string> RequiredKeys = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
	{
		{ "Eikthyr", "defeated_eikthyr" },
		{ "gd_king", "defeated_gdking" },
		{ "Bonemass", "defeated_bonemass" },
		{ "Dragon", "defeated_dragon" },
		{ "GoblinKing", "defeated_goblinking" },
		{ "SeekerQueen", "defeated_queen" },
		{ "Fader", "defeated_fader" },
		{ "FrozenKing", "defeated_frozenking_p3" },
		{ "FrozenKing_p2", "defeated_frozenking_p3" },
		{ "FrozenKing_p3", "defeated_frozenking_p3" }
	};

	private void Awake()
	{
		//IL_004e: 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_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Expected O, but got Unknown
		//IL_0086: Expected O, but got Unknown
		Type type = AccessTools.TypeByName("CreatureManager.CreatureKarmaManager");
		MethodInfo methodInfo = ((type == null) ? null : AccessTools.Method(type, "TrySelectEnforcerCandidate", (Type[])null, (Type[])null));
		if (methodInfo == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"CreatureManager Enforcer selection method was not found.");
			return;
		}
		new Harmony("codex.enforcerbossprogression").Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(Plugin), "FilterLockedBosses", (Type[])null), new HarmonyMethod(typeof(Plugin), "RestoreLockedBosses", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Enforcer bosses are locked behind their world defeat keys.");
	}

	private static void FilterLockedBosses(IList candidates, out List<RemovedCandidate> __state)
	{
		__state = new List<RemovedCandidate>();
		if (candidates == null || (Object)(object)ZoneSystem.instance == (Object)null)
		{
			return;
		}
		for (int num = candidates.Count - 1; num >= 0; num--)
		{
			object obj = candidates[num];
			string bossPrefab = GetBossPrefab(obj);
			if (RequiredKeys.TryGetValue(bossPrefab, out var value) && !ZoneSystem.instance.GetGlobalKey(value))
			{
				__state.Add(new RemovedCandidate
				{
					Index = num,
					Value = obj
				});
				candidates.RemoveAt(num);
			}
		}
	}

	private static void RestoreLockedBosses(IList candidates, List<RemovedCandidate> __state)
	{
		if (candidates != null && __state != null)
		{
			for (int num = __state.Count - 1; num >= 0; num--)
			{
				RemovedCandidate removedCandidate = __state[num];
				candidates.Insert(removedCandidate.Index, removedCandidate.Value);
			}
		}
	}

	private static string GetBossPrefab(object candidate)
	{
		if (candidate == null)
		{
			return "";
		}
		FieldInfo fieldInfo = AccessTools.Field(candidate.GetType(), "Summon");
		object obj = ((fieldInfo == null) ? null : fieldInfo.GetValue(candidate));
		if (obj == null)
		{
			return "";
		}
		FieldInfo fieldInfo2 = AccessTools.Field(obj.GetType(), "Boss");
		return (fieldInfo2 == null) ? "" : ((fieldInfo2.GetValue(obj) as string) ?? "");
	}
}

using System;
using System.Collections;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Codex.EpicLootCraftFromChests;

[BepInPlugin("codex.epiclootcraftfromchests", "Epic Loot Craft From Chests", "1.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
	private static Type _inventoryManagement;

	private static Type _chestSource;

	private static Type _tableUi;

	private static MethodInfo _nearby;

	private static MethodInfo _count;

	private static MethodInfo _consume;

	private static PropertyInfo _instance;

	private static ManualLogSource _log;

	private static string _lastRequirementDiagnostic;

	private void Awake()
	{
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Expected O, but got Unknown
		//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Expected O, but got Unknown
		//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Expected O, but got Unknown
		//IL_037c: Unknown result type (might be due to invalid IL or missing references)
		//IL_038a: Expected O, but got Unknown
		_log = ((BaseUnityPlugin)this).Logger;
		_inventoryManagement = FindType("EpicLoot_UnityLib.InventoryManagement");
		_chestSource = FindType("NoVikingLeftBehind.ChestSource");
		_tableUi = FindType("EpicLoot_UnityLib.EnchantingTableUI");
		if (_inventoryManagement == null || _chestSource == null || _tableUi == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"EpicLoot or NoVikingLeftBehind API was not found; chest bridge was not applied.");
			return;
		}
		_nearby = AccessTools.Method(_chestSource, "Nearby", (Type[])null, (Type[])null);
		_count = AccessTools.Method(_chestSource, "Count", (Type[])null, (Type[])null);
		_consume = AccessTools.Method(_chestSource, "Consume", (Type[])null, (Type[])null);
		_instance = AccessTools.Property(_tableUi, "instance");
		MethodInfo methodInfo = AccessTools.Method(_inventoryManagement, "CountItem", new Type[1] { typeof(string) }, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(_inventoryManagement, "RemoveItem", new Type[2]
		{
			typeof(string),
			typeof(int)
		}, (Type[])null);
		if (_nearby == null || _count == null || _consume == null || _instance == null || methodInfo == null || methodInfo2 == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"A required CraftFromChests bridge method was not found; patch was not applied.");
			return;
		}
		Harmony val = new Harmony("codex.epiclootcraftfromchests");
		val.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin).GetMethod("CountItemPostfix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(Plugin).GetMethod("RemoveItemPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo methodInfo3 = AccessTools.Method(typeof(Player), "HaveRequirements", new Type[4]
		{
			typeof(Recipe),
			typeof(bool),
			typeof(int),
			typeof(int)
		}, (Type[])null);
		MethodInfo methodInfo4 = AccessTools.Method(typeof(Player), "ConsumeResources", new Type[4]
		{
			typeof(Requirement[]),
			typeof(int),
			typeof(int),
			typeof(int)
		}, (Type[])null);
		if (methodInfo3 != null && methodInfo4 != null)
		{
			val.Patch((MethodBase)methodInfo3, (HarmonyMethod)null, LastPostfix("HaveRequirementsPostfix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo5 = AccessTools.Method(typeof(Player), "HaveRequirementItems", new Type[4]
			{
				typeof(Recipe),
				typeof(bool),
				typeof(int),
				typeof(int)
			}, (Type[])null);
			if (methodInfo5 != null)
			{
				val.Patch((MethodBase)methodInfo5, (HarmonyMethod)null, LastPostfix("HaveRequirementItemsPostfix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			val.Patch((MethodBase)methodInfo4, new HarmonyMethod(typeof(Plugin).GetMethod("ConsumeResourcesPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Valheim crafting requirement and consumption bridge applied.");
		}
		else
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"Valheim crafting bridge methods were not found; only EpicLoot enchanting is patched.");
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)"EpicLoot enchanting table now uses nearby NoVikingLeftBehind chests.");
	}

	private static Type FindType(string fullName)
	{
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly in assemblies)
		{
			Type type = assembly.GetType(fullName, throwOnError: false);
			if (type != null)
			{
				return type;
			}
		}
		return null;
	}

	private static HarmonyMethod LastPostfix(string methodName)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Expected O, but got Unknown
		HarmonyMethod val = new HarmonyMethod(typeof(Plugin).GetMethod(methodName, BindingFlags.Static | BindingFlags.NonPublic));
		val.priority = 0;
		return val;
	}

	private static bool IsEnchantingTableOpen()
	{
		if (_instance == null)
		{
			return false;
		}
		object? value = _instance.GetValue(null);
		Component val = (Component)((value is Component) ? value : null);
		return (Object)(object)val != (Object)null && val.gameObject.activeInHierarchy;
	}

	private static IList NearbyChests()
	{
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null || _nearby == null)
		{
			return null;
		}
		return _nearby.Invoke(null, new object[1] { ((Component)localPlayer).transform.position }) as IList;
	}

	private static int ChestCount(string itemName, IList chests)
	{
		if (chests == null || _count == null)
		{
			return 0;
		}
		return Convert.ToInt32(_count.Invoke(null, new object[3] { itemName, chests, -1 }));
	}

	private static int ConsumeFromChests(string itemName, int amount, IList chests)
	{
		if (amount <= 0 || chests == null || _consume == null)
		{
			return 0;
		}
		return Convert.ToInt32(_consume.Invoke(null, new object[4] { itemName, amount, -1, chests }));
	}

	private static void CountItemPostfix(string item, ref int __result)
	{
		if (IsEnchantingTableOpen())
		{
			__result += ChestCount(item, NearbyChests());
		}
	}

	private static bool RemoveItemPrefix(string item, int amount)
	{
		if (!IsEnchantingTableOpen())
		{
			return true;
		}
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null || amount <= 0)
		{
			return true;
		}
		Inventory inventory = ((Humanoid)localPlayer).GetInventory();
		int num = Math.Min(amount, inventory.CountItems(item, -1, true));
		if (num > 0)
		{
			inventory.RemoveItem(item, num, -1, true);
		}
		int num2 = amount - num;
		if (num2 > 0)
		{
			ConsumeFromChests(item, num2, NearbyChests());
		}
		return false;
	}

	private static void HaveRequirementsPostfix(Recipe recipe, bool discover, int qualityLevel, int amount, ref bool __result)
	{
		if (!__result && !((Object)(object)recipe == (Object)null) && recipe.m_resources != null && !((Object)(object)Player.m_localPlayer == (Object)null) && HasRequiredStationForNewCraft(recipe, qualityLevel) && CanCoverRequirements(recipe.m_resources, qualityLevel, amount))
		{
			__result = true;
		}
	}

	private static void HaveRequirementItemsPostfix(Recipe piece, bool discover, int qualityLevel, int amount, ref bool __result)
	{
		if (!__result && !((Object)(object)piece == (Object)null) && piece.m_resources != null && !((Object)(object)Player.m_localPlayer == (Object)null) && HasRequiredStationForNewCraft(piece, qualityLevel) && CanCoverRequirements(piece.m_resources, qualityLevel, amount))
		{
			__result = true;
		}
	}

	private static bool HasRequiredStationForNewCraft(Recipe recipe, int qualityLevel)
	{
		if (qualityLevel > 1 || (Object)(object)recipe.m_craftingStation == (Object)null)
		{
			return true;
		}
		CraftingStation currentCraftingStation = Player.m_localPlayer.GetCurrentCraftingStation();
		return (Object)(object)currentCraftingStation != (Object)null && currentCraftingStation.GetLevel(true) >= recipe.m_minStationLevel;
	}

	private static bool ConsumeResourcesPrefix(Requirement[] requirements, int qualityLevel, int itemQuality, int multiplier)
	{
		if (requirements == null || (Object)(object)Player.m_localPlayer == (Object)null)
		{
			return true;
		}
		if (!NeedsChestMaterials(requirements, qualityLevel, multiplier))
		{
			return true;
		}
		if (!CanCoverRequirements(requirements, qualityLevel, multiplier))
		{
			return true;
		}
		Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
		IList chests = NearbyChests();
		foreach (Requirement val in requirements)
		{
			if (!IsConsumableRequirement(val))
			{
				continue;
			}
			string text = RequirementItemName(val);
			if (!string.IsNullOrEmpty(text))
			{
				int num = val.GetAmount(qualityLevel) * multiplier;
				int num2 = Math.Min(num, inventory.CountItems(text, -1, true));
				if (num2 > 0)
				{
					inventory.RemoveItem(text, num2, -1, true);
				}
				int num3 = num - num2;
				if (num3 > 0)
				{
					ConsumeFromChests(text, num3, chests);
				}
			}
		}
		return false;
	}

	private static bool NeedsChestMaterials(Requirement[] requirements, int qualityLevel, int multiplier)
	{
		Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
		foreach (Requirement val in requirements)
		{
			if (IsConsumableRequirement(val))
			{
				int num = val.GetAmount(qualityLevel) * multiplier;
				string text = RequirementItemName(val);
				if (!string.IsNullOrEmpty(text) && inventory.CountItems(text, -1, true) < num)
				{
					return true;
				}
			}
		}
		return false;
	}

	private static bool CanCoverRequirements(Requirement[] requirements, int qualityLevel, int multiplier)
	{
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null)
		{
			return false;
		}
		Inventory inventory = ((Humanoid)localPlayer).GetInventory();
		IList chests = NearbyChests();
		foreach (Requirement val in requirements)
		{
			if (!IsConsumableRequirement(val))
			{
				continue;
			}
			string text = RequirementItemName(val);
			if (!string.IsNullOrEmpty(text))
			{
				int num = val.GetAmount(qualityLevel) * multiplier;
				int num2 = inventory.CountItems(text, -1, true);
				int num3 = ChestCount(text, chests);
				int num4 = num2 + num3;
				if (num4 < num)
				{
					return false;
				}
			}
		}
		return true;
	}

	private static bool IsConsumableRequirement(Requirement requirement)
	{
		if (requirement == null || (Object)(object)requirement.m_resItem == (Object)null)
		{
			return false;
		}
		if (requirement.m_upgraderResource)
		{
			return false;
		}
		string text = RequirementItemName(requirement);
		return string.IsNullOrEmpty(text) || text.IndexOf("$item_upgrader_", StringComparison.Ordinal) < 0;
	}

	private static void LogRequirementDiagnostic(string itemName, int required, int carried, int chestCount, int containerCount)
	{
		string text = $"Requirement {itemName}: need={required}, player={carried}, chests={chestCount}, nearbyContainers={containerCount}";
		if (!(text == _lastRequirementDiagnostic))
		{
			_lastRequirementDiagnostic = text;
			if (_log != null)
			{
				_log.LogInfo((object)text);
			}
		}
	}

	private static string RequirementItemName(Requirement requirement)
	{
		if (requirement == null || (Object)(object)requirement.m_resItem == (Object)null || requirement.m_resItem.m_itemData == null || requirement.m_resItem.m_itemData.m_shared == null)
		{
			return null;
		}
		return requirement.m_resItem.m_itemData.m_shared.m_name;
	}
}

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using EpicLoot.CraftingV2;
using EpicLoot_UnityLib;
using HarmonyLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Codex.EpicLootDisenchantKeepItem;

[BepInPlugin("codex.epiclootdisenchantkeepitem", "Epic Loot Disenchant Keep Item", "1.0.0")]
public sealed class Plugin : BaseUnityPlugin
{
	private void Awake()
	{
		//IL_0063: 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_0078: Expected O, but got Unknown
		MethodInfo methodInfo = AccessTools.Method(typeof(EnchantingUIController), "DisenchantItem", (Type[])null, (Type[])null);
		MethodInfo method = typeof(Plugin).GetMethod("DisenchantPostfix", BindingFlags.Static | BindingFlags.NonPublic);
		if (methodInfo == null || method == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Could not find EpicLoot's DisenchantItem method; patch was not applied.");
			return;
		}
		new Harmony("codex.epiclootdisenchantkeepitem").Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Disenchant now keeps the item and gives no materials.");
	}

	private static void DisenchantPostfix(ref List<InventoryItemListElement> __result, ref bool bonusRolled)
	{
		if (__result != null)
		{
			__result.Clear();
		}
		bonusRolled = false;
	}
}

using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Codex.EpicLootMovementSpeedCap;

[BepInPlugin("codex.epiclootmovementspeedcap", "Epic Loot Movement Speed Cap", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
	private const float MaximumEpicLootBonus = 0.75f;

	private void Awake()
	{
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Expected O, but got Unknown
		Type type = FindType("EpicLoot.MagicItemEffects.ModifyMovementSpeed");
		MethodInfo methodInfo = ((type == null) ? null : AccessTools.Method(type, "GetModifyMovementSpeedAmount", new Type[1] { typeof(Player) }, (Type[])null));
		if (methodInfo == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"EpicLoot movement-speed calculation was not found; cap was not applied.");
			return;
		}
		new Harmony("codex.epiclootmovementspeedcap").Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin).GetMethod("CapPostfix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Total movement-speed bonus supplied by EpicLoot is capped at +75%.");
	}

	private static Type FindType(string fullName)
	{
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly in assemblies)
		{
			Type type = assembly.GetType(fullName, throwOnError: false);
			if (type != null)
			{
				return type;
			}
		}
		return null;
	}

	private static void CapPostfix(ref float __result)
	{
		__result = Mathf.Min(__result, 0.75f);
	}
}

using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Codex.EpicLootRecallOwnerLock;

[BepInPlugin("codex.epiclootrecallownerlock", "Epic Loot Recall Owner Lock", "1.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
	private const string OwnerKey = "codex_recall_owner";

	private const string ExpiryKey = "codex_recall_expiry";

	private static ConfigEntry<int> _lockSeconds;

	private static FieldInfo _itemDropNview;

	private static FieldInfo _projectileOwner;

	private void Awake()
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Expected O, but got Unknown
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0182: Expected O, but got Unknown
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a9: Expected O, but got Unknown
		//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Expected O, but got Unknown
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f9: Expected O, but got Unknown
		_lockSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("General", "OwnerLockSeconds", 30, new ConfigDescription("Seconds that only the original thrower may pick up a recalled weapon.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 120), new object[0]));
		Type type = FindType("EpicLoot.MagicItemEffects.RecallWeapon_Projectile_SpawnOnHit_Patch");
		if (type == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"EpicLoot Recall implementation was not found; owner lock was not applied.");
			return;
		}
		MethodInfo methodInfo = AccessTools.Method(type, "IssueItemRecall", (Type[])null, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(ItemDrop), "Interact", new Type[3]
		{
			typeof(Humanoid),
			typeof(bool),
			typeof(bool)
		}, (Type[])null);
		MethodInfo methodInfo3 = AccessTools.Method(typeof(ItemDrop), "Pickup", new Type[1] { typeof(Humanoid) }, (Type[])null);
		_itemDropNview = AccessTools.Field(typeof(ItemDrop), "m_nview");
		_projectileOwner = AccessTools.Field(typeof(Projectile), "m_owner");
		if (methodInfo == null || methodInfo2 == null || methodInfo3 == null || _itemDropNview == null || _projectileOwner == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"A required Recall or ItemDrop method was not found; owner lock was not applied.");
			return;
		}
		Harmony val = new Harmony("codex.epiclootrecallownerlock");
		val.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(Plugin).GetMethod("RecallPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(Plugin).GetMethod("PickupPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(Plugin).GetMethod("AutoPickupPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)("Recall weapons are now owner-locked against manual and automatic pickup for " + _lockSeconds.Value + " seconds."));
	}

	private static Type FindType(string fullName)
	{
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly in assemblies)
		{
			Type type = assembly.GetType(fullName, throwOnError: false);
			if (type != null)
			{
				return type;
			}
		}
		return null;
	}

	private static void RecallPrefix(object[] __args)
	{
		if (__args == null || __args.Length < 2)
		{
			return;
		}
		object obj = __args[0];
		ItemDrop itemDrop = (ItemDrop)((obj is ItemDrop) ? obj : null);
		object obj2 = __args[1];
		Projectile val = (Projectile)((obj2 is Projectile) ? obj2 : null);
		Player val2 = (Player)(((Object)(object)val != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
		ZNetView nview = GetNview(itemDrop);
		if (!((Object)(object)nview == (Object)null) && nview.IsValid() && !((Object)(object)val2 == (Object)null))
		{
			ZDO zDO = nview.GetZDO();
			if (zDO != null)
			{
				double num = (((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetTimeSeconds() : 0.0);
				zDO.Set("codex_recall_owner", val2.GetPlayerID());
				zDO.Set("codex_recall_expiry", (long)Math.Ceiling(num + (double)Math.Max(1, _lockSeconds.Value)));
			}
		}
	}

	private static bool PickupPrefix(ItemDrop __instance, object[] __args)
	{
		ZNetView nview = GetNview(__instance);
		if ((Object)(object)nview == (Object)null || !nview.IsValid() || __args == null || __args.Length < 1)
		{
			return true;
		}
		object obj = __args[0];
		return CanPickup(__instance, (Player)((obj is Player) ? obj : null));
	}

	private static bool AutoPickupPrefix(ItemDrop __instance, Humanoid character)
	{
		return CanPickup(__instance, (Player)(object)((character is Player) ? character : null));
	}

	private static bool CanPickup(ItemDrop itemDrop, Player player)
	{
		ZNetView nview = GetNview(itemDrop);
		if ((Object)(object)nview == (Object)null || !nview.IsValid() || (Object)(object)player == (Object)null)
		{
			return true;
		}
		ZDO zDO = nview.GetZDO();
		if (zDO == null)
		{
			return true;
		}
		long num = zDO.GetLong("codex_recall_owner", 0L);
		long num2 = zDO.GetLong("codex_recall_expiry", 0L);
		double num3 = (((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetTimeSeconds() : 0.0);
		if (num != 0 && (double)num2 > num3 && num != player.GetPlayerID())
		{
			((Character)player).Message((MessageType)2, "This recalled weapon belongs to another Viking.", 0, (Sprite)null, false);
			return false;
		}
		return true;
	}

	private static ZNetView GetNview(ItemDrop itemDrop)
	{
		return (ZNetView)(((Object)(object)itemDrop != (Object)null && _itemDropNview != null) ? /*isinst with value type is only supported in some contexts*/: null);
	}
}

using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Codex.EpicLootRecallTracker;

[BepInPlugin("codex.epiclootrecalltracker", "Epic Loot Recall Compass", "2.0.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
	private static FieldInfo _itemDropNview;

	private static FieldInfo _projectileOwner;

	private static bool _tracking;

	private static ZDOID _trackedId;

	private static Vector3 _lastPosition;

	private static float _lastSeenAt;

	private static float _nextHudUpdate;

	private static object _compass;

	private static MethodInfo _showCompass;

	private static MethodInfo _hideCompass;

	private static MethodInfo _setHint;

	private static MethodInfo _setItems;

	private static ConfigEntry<float> _hideDistance;

	private static ConfigEntry<float> _maxTrackingMinutes;

	private void Awake()
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Expected O, but got Unknown
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Expected O, but got Unknown
		//IL_0260: Unknown result type (might be due to invalid IL or missing references)
		//IL_0310: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Unknown result type (might be due to invalid IL or missing references)
		//IL_033a: Expected O, but got Unknown
		_hideDistance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "HideDistance", 3f, new ConfigDescription("Stop tracking after the recalled item disappears this close to its owner.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f), new object[0]));
		_maxTrackingMinutes = ((BaseUnityPlugin)this).Config.Bind<float>("General", "MaxTrackingMinutes", 30f, new ConfigDescription("Safety timeout for a weapon that can no longer be recovered.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 180f), new object[0]));
		_itemDropNview = AccessTools.Field(typeof(ItemDrop), "m_nview");
		_projectileOwner = AccessTools.Field(typeof(Projectile), "m_owner");
		Type type = FindType("EpicLoot.MagicItemEffects.RecallWeapon_Projectile_SpawnOnHit_Patch");
		Type type2 = FindType("NoVikingLeftBehind.GraveCompassHud");
		if (_itemDropNview == null || _projectileOwner == null || type == null || type2 == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"EpicLoot Recall or NVLB GraveCompass was not found; recall compass was not applied.");
			return;
		}
		MethodInfo methodInfo = AccessTools.Method(type, "IssueItemRecall", new Type[2]
		{
			typeof(ItemDrop),
			typeof(Projectile)
		}, (Type[])null);
		_showCompass = AccessTools.Method(type2, "Show", new Type[3]
		{
			typeof(Player),
			typeof(Vector3),
			typeof(float)
		}, (Type[])null);
		_hideCompass = AccessTools.Method(type2, "Hide", (Type[])null, (Type[])null);
		_setHint = AccessTools.Method(type2, "SetHint", new Type[1] { typeof(string) }, (Type[])null);
		_setItems = AccessTools.Method(type2, "SetItems", new Type[1] { typeof(int) }, (Type[])null);
		if (methodInfo == null || _showCompass == null || _hideCompass == null || _setHint == null || _setItems == null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"A required Recall/GraveCompass method was not found; recall compass was not applied.");
			return;
		}
		_compass = type2;
		SetField(type2, "Offset", (object)new Vector2(0f, 145f));
		SetField(type2, "ArrowChar", "^");
		SetField(type2, "ArrowScale", 1.6f);
		SetField(type2, "EdgeMode", true);
		SetField(type2, "EdgeMargin", 60f);
		SetField(type2, "HintAlpha", 0.85f);
		SetField(type2, "HintScale", 0.8f);
		_setItems.Invoke(null, new object[1] { 0 });
		new Harmony("codex.epiclootrecalltracker").Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(Plugin).GetMethod("RecallPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Recall tracker now uses the NVLB GraveCompass HUD with distance and X/Z coordinates.");
	}

	private static Type FindType(string fullName)
	{
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly in assemblies)
		{
			Type type = assembly.GetType(fullName, throwOnError: false);
			if (type != null)
			{
				return type;
			}
		}
		return null;
	}

	private static void SetField(Type type, string name, object value)
	{
		FieldInfo fieldInfo = AccessTools.Field(type, name);
		if (fieldInfo != null)
		{
			fieldInfo.SetValue(null, value);
		}
	}

	private static void RecallPrefix(ItemDrop item, Projectile projectile)
	{
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		Player val = (Player)(((Object)(object)projectile != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
		if (!((Object)(object)val == (Object)null) && !((Object)(object)val != (Object)(object)Player.m_localPlayer) && !((Object)(object)item == (Object)null))
		{
			object? value = _itemDropNview.GetValue(item);
			ZNetView val2 = (ZNetView)((value is ZNetView) ? value : null);
			if (!((Object)(object)val2 == (Object)null) && val2.IsValid() && val2.GetZDO() != null)
			{
				_trackedId = val2.GetZDO().m_uid;
				_lastPosition = ((Component)item).transform.position;
				_lastSeenAt = Time.time;
				_nextHudUpdate = 0f;
				_tracking = true;
				HideCompass();
			}
		}
	}

	private void Update()
	{
		//IL_0042: 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_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_01a4: Unknown result type (might be due to invalid IL or missing references)
		if (!_tracking || (Object)(object)Player.m_localPlayer == (Object)null || _compass == null)
		{
			return;
		}
		ZNetScene instance = ZNetScene.instance;
		GameObject val = (((Object)(object)instance != (Object)null) ? instance.FindInstance(_trackedId) : null);
		if ((Object)(object)val != (Object)null)
		{
			_lastPosition = val.transform.position;
			_lastSeenAt = Time.time;
		}
		else
		{
			float num = Vector3.Distance(((Component)Player.m_localPlayer).transform.position, _lastPosition);
			if (num <= _hideDistance.Value)
			{
				StopTracking();
				return;
			}
			if (Time.time - _lastSeenAt >= _maxTrackingMinutes.Value * 60f)
			{
				StopTracking();
				return;
			}
		}
		if (!(Time.time < _nextHudUpdate))
		{
			_nextHudUpdate = Time.time + 0.1f;
			float num2 = Vector3.Distance(((Component)Player.m_localPlayer).transform.position, _lastPosition);
			string arg = (((Object)(object)val == (Object)null) ? " · LAST KNOWN" : "");
			string text = $"Recall Weapon · X {_lastPosition.x:0}  Z {_lastPosition.z:0}{arg}";
			_setHint.Invoke(null, new object[1] { text });
			_showCompass.Invoke(null, new object[3]
			{
				Player.m_localPlayer,
				_lastPosition,
				num2
			});
		}
	}

	private static void HideCompass()
	{
		if (_compass != null && _hideCompass != null)
		{
			_hideCompass.Invoke(null, null);
		}
	}

	private static void StopTracking()
	{
		_tracking = false;
		HideCompass();
	}

	private void OnDestroy()
	{
		StopTracking();
	}
}