using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BetterRunning")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BetterRunning")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("B8BADF26-96F5-4A0D-BEC9-F35F650D1B3A")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BetterRunning;

[BepInPlugin("me.delusional.betterRunning", "BetterRunning", "1.0.0.0")]
public class MainClass : BaseUnityPlugin
{
	private class StaminaPatch
	{
		[HarmonyPatch(typeof(PlayerStatus), "Stamina")]
		[HarmonyPrefix]
		private static bool PrefixStamina(ref float ___staminaDrainRate, ref float ___staminaRegenRate, ref float ___jumpDrain)
		{
			___staminaDrainRate = 6f;
			___staminaRegenRate = 7.5f;
			___jumpDrain = 5f;
			return true;
		}
	}

	public static MainClass instance;

	public ManualLogSource log;

	public Harmony harmony;

	private void Awake()
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Expected O, but got Unknown
		if ((Object)(object)instance == (Object)null)
		{
			instance = this;
		}
		else
		{
			Object.Destroy((Object)(object)this);
		}
		log = ((BaseUnityPlugin)this).Logger;
		harmony = new Harmony("me.delusional.betterRunning");
		harmony.PatchAll(typeof(StaminaPatch));
		log.LogInfo((object)"Better Running loaded");
	}

	private void OnDestroy()
	{
		harmony.UnpatchSelf();
	}
}

using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("MuckMod.FasterDayCycle")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("MuckMod.FasterDayCycle")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5f96b002-a362-42a2-8f86-02ded696c64e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MuckMod.FasterDayCycle;

public class FasterDayCyclePatch
{
	private static float _dayMultiplier;

	private static PropertyInfo _totalTimeProp;

	[HarmonyPatch(typeof(GameLoop), "NewDay")]
	[HarmonyPostfix]
	private static void NewDayPostfix(ref GameLoop __instance)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		_dayMultiplier += (float)GameManager.gameSettings.difficulty / 10f;
		if (__instance.currentDay == 0)
		{
			_dayMultiplier = 0f;
		}
		Debug.Log((object)$"Day speed multiplier set to {_dayMultiplier}");
	}

	[HarmonyPatch(typeof(DayCycle), "Update")]
	[HarmonyPrefix]
	private static void DayCycleUpdatePrefix(ref DayCycle __instance)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Invalid comparison between Unknown and I4
		if ((int)GameManager.state == 1 && DayCycle.time <= 0.5f)
		{
			float num = 1f * __instance.timeSpeed / DayCycle.dayDuration * Time.deltaTime;
			num *= _dayMultiplier;
			DayCycle.time += num;
			DayCycle.time %= 1f;
			if (_totalTimeProp == null)
			{
				_totalTimeProp = typeof(DayCycle).GetProperty("totalTime");
			}
			_totalTimeProp.SetValue(__instance, (float)_totalTimeProp.GetValue(__instance) + num);
		}
	}
}
[BepInPlugin("dnmal.fasterDayCycle", "FasterDayCycle", "1.1.0")]
public class Main : BaseUnityPlugin
{
	public const string Id = "dnmal.fasterDayCycle";

	public static Main instance;

	public Harmony harmony;

	private void Awake()
	{
		if ((Object)(object)instance == (Object)null)
		{
			instance = this;
		}
		else
		{
			Object.Destroy((Object)(object)this);
		}
		Harmony.CreateAndPatchAll(typeof(FasterDayCyclePatch), (string)null);
	}

	private void OnDestroy()
	{
		harmony.UnpatchSelf();
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("DoubleChestsCosts")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("DoubleChestsCosts")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("52b7f4b5-e002-450b-8c2a-85fd506cc9f7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace DoubledChestsCost;

[BepInPlugin("absolomb.DoubledChestsCost", "Doubled Chests Cost", "1.0.0")]
public class DoubledChestsCost : BaseUnityPlugin
{
	public const string pluginGuid = "absolomb.DoubledChestsCost";

	public const string pluginName = "Doubled Chests Cost";

	public const string pluginVersion = "1.0.0";

	public void Awake()
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Expected O, but got Unknown
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Expected O, but got Unknown
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading Doubled Chests Cost");
		Harmony val = new Harmony("absolomb.DoubledChestsCost");
		MethodInfo methodInfo = AccessTools.Method(typeof(GameManager), "ChestPriceMultiplier", (Type[])null, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(GameManagerPatch), "ChestPriceMultiplier_Patch", (Type[])null, (Type[])null);
		val.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
	}
}
public class GameManagerPatch
{
	[HarmonyPatch(typeof(GameManager), "ChestPriceMultiplier")]
	private static float ChestPriceMultiplier_Patch(float price)
	{
		return 2f * price;
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using SuperMuckApi.Achievements;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("SuperMuckApi")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SuperMuckApi")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fb49945e-97eb-4c06-9cda-47837b300b35")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace SuperMuckApi
{
	[BepInPlugin("Fano.SuperMuckApi", "SuperMuckApi", "1.0.0")]
	public class SuperMuckApi : BaseUnityPlugin
	{
		public void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("Fano.SuperMuckApi.Harmony").PatchAll();
		}
	}
}
namespace SuperMuckApi.Items
{
	public enum CraftingType
	{
		Handcrafting,
		WorkbenchNew,
		AnvilNew
	}
	public class ModdedCraftRequirement
	{
		public string name;

		public int amount;

		public ModdedCraftRequirement(string name, int amount)
		{
			this.name = name;
			this.amount = amount;
		}
	}
	public class ModdedItem : InventoryItem
	{
		public List<ModdedCraftRequirement> craftRequirement = new List<ModdedCraftRequirement>();

		public string StationCraft;

		public int tab = 0;

		public CraftingType craftingType;

		public void AddRequirement(params ModdedCraftRequirement[] requirements)
		{
			foreach (ModdedCraftRequirement item in requirements)
			{
				craftRequirement.Add(item);
			}
		}

		public ModdedItem()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			base.important = false;
			base.id = 0;
			base.name = "ModdedItem";
			base.description = "a Modded Item.";
			base.type = (ItemType)0;
			base.tier = 0;
			base.rotationOffset = new Vector3(0f, 0f, 0f);
			base.positionOffset = new Vector3(0f, 0f, 0f);
			base.scale = 1f;
			base.stackable = true;
			base.amount = 15;
			base.max = 69;
			base.resourceDamage = 1;
			base.attackDamage = 1;
			base.attackSpeed = 2f;
			base.attackRange = 0f;
			base.sharpness = 0f;
			base.craftable = true;
			base.unlockWithFirstRequirementOnly = false;
			base.requirements = (CraftRequirement[])(object)new CraftRequirement[0];
			base.craftAmount = 5;
			base.stationRequirement = (InventoryItem)(object)this;
			base.buildable = false;
			base.grid = false;
			base.buildRotation = new Vector3(0f, 0f, 0f);
			base.processable = false;
			base.processType = (ProcessType)0;
			base.processTime = 0f;
			base.heal = 0f;
			base.hunger = 0f;
			base.stamina = 0f;
			base.armor = 0;
			base.swingFx = false;
			base.tag = (ItemTag)0;
			base.rarity = (ItemRarity)0;
			base.attackTypes = (Weakness[])(object)new Weakness[0];
			craftingType = CraftingType.Handcrafting;
		}
	}
	[HarmonyPatch]
	public static class ModdedItemManager
	{
		public static readonly List<ModdedItem> ModdedItems = new List<ModdedItem>();

		public static InventoryItem RegisterItem(ModdedItem item)
		{
			ModdedItem moddedItem = ScriptableObject.CreateInstance<ModdedItem>();
			((InventoryItem)moddedItem).Copy((InventoryItem)(object)item, 1);
			moddedItem.craftRequirement = item.craftRequirement;
			moddedItem.craftingType = item.craftingType;
			moddedItem.tab = item.tab;
			((InventoryItem)moddedItem).id = ModdedItems.Count;
			ModdedItems.Add(moddedItem);
			return (InventoryItem)(object)moddedItem;
		}

		[HarmonyPatch(typeof(ItemManager), "InitAllItems")]
		[HarmonyPostfix]
		private static void InitAllItems()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			foreach (ModdedItem moddedItem in ModdedItems)
			{
				((InventoryItem)moddedItem).id = ItemManager.Instance.allItems.Count;
				CraftRequirement[] array = (CraftRequirement[])(object)new CraftRequirement[moddedItem.craftRequirement.Count];
				int num = 0;
				foreach (ModdedCraftRequirement item in moddedItem.craftRequirement)
				{
					CraftRequirement val = new CraftRequirement
					{
						item = ItemManager.Instance.GetItemByName(item.name),
						amount = item.amount
					};
					array[num] = val;
					num++;
				}
				((InventoryItem)moddedItem).requirements = array;
				ItemManager.Instance.allItems.Add(((InventoryItem)moddedItem).id, (InventoryItem)(object)moddedItem);
			}
		}

		[HarmonyPatch(typeof(CraftingUI), "Awake")]
		[HarmonyPostfix]
		private static void CraftingPostfix(CraftingUI __instance)
		{
			foreach (ModdedItem moddedItem in ModdedItems)
			{
				if (!(moddedItem.craftingType.ToString() != ((Object)__instance).name) && ((InventoryItem)moddedItem).craftable)
				{
					InventoryItem[] items = __instance.tabs[moddedItem.tab].items;
					InventoryItem[] array = (InventoryItem[])(object)new InventoryItem[items.Length + 1];
					items.CopyTo(array, 0);
					array[items.Length] = ItemManager.Instance.allItems[((InventoryItem)moddedItem).id];
					__instance.tabs[moddedItem.tab].items = array;
				}
			}
		}

		[HarmonyPatch(typeof(InventoryUI), "AddItemToInventory")]
		[HarmonyPostfix]
		private static void AddItemToInventoryPostfix(InventoryItem item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			foreach (ModdedItem moddedItem in ModdedItems)
			{
				if (!((InventoryItem)moddedItem).craftable)
				{
					continue;
				}
				foreach (ModdedCraftRequirement item2 in moddedItem.craftRequirement)
				{
					if (item2.name == item.name)
					{
						UiEvents.Instance.CheckProcessedItem(((InventoryItem)moddedItem).id);
					}
				}
			}
		}
	}
}
namespace SuperMuckApi.Commands
{
	[HarmonyPatch]
	public static class CommandManager
	{
		public delegate void Command(string[] Args);

		public static readonly List<string> CommandsList = new List<string>();

		private static Dictionary<string, Command> RegisteredCommands = new Dictionary<string, Command>();

		public static void RegisterCommand(string id, Command command)
		{
			RegisteredCommands.Add(id, command);
			CommandsList.Add(id);
		}

		[HarmonyPatch(typeof(ChatBox), "Awake")]
		[HarmonyPostfix]
		private static void Start(ChatBox __instance)
		{
			string[] commands = __instance.commands;
			foreach (string item in commands)
			{
				CommandsList.Add(item);
			}
		}

		[HarmonyPatch(typeof(PlayerMovement), "Jump")]
		[HarmonyPostfix]
		private static void Start(PlayerMovement __instance)
		{
			Console.WriteLine("JUMP");
			CustomAchievementManager.UnlockAchievement("Jump");
		}

		[HarmonyPatch(typeof(ChatBox), "ChatCommand")]
		[HarmonyPrefix]
		public static bool ChatCommand(string message)
		{
			Console.WriteLine(message);
			string text = message.Split(new char[1] { ' ' })[0].Substring(1);
			string[] args = message.Substring(1).Split(new char[1] { ' ' });
			foreach (string key in RegisteredCommands.Keys)
			{
				if (key == text)
				{
					RegisteredCommands[key](args);
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(Commands), "PredictCommands")]
		[HarmonyPrefix]
		public static bool PreditCommands(Commands __instance, ref string ___suggestedText)
		{
			if (!ChatBox.Instance.typing)
			{
				if (((TMP_Text)__instance.suggestText).text != "")
				{
					___suggestedText = "";
					((TMP_Text)__instance.suggestText).text = "";
				}
				return false;
			}
			___suggestedText = "";
			string text = __instance.inputField.text;
			if (text.Length < 1)
			{
				return false;
			}
			string text2 = text.Split(new char[1] { ' ' }).Last();
			if (text2.Length < 1)
			{
				return false;
			}
			string text3 = text2[0].ToString() ?? "";
			string text4 = text2.Remove(0, 1);
			if (text3 == "/")
			{
				foreach (string commands in CommandsList)
				{
					if (commands.StartsWith(text4))
					{
						___suggestedText = text;
						int num = commands.Length - text4.Length;
						___suggestedText += commands.Substring(commands.Length - num);
						return false;
					}
				}
			}
			string[] array = text.Split();
			if (array.Length < 2)
			{
				return false;
			}
			int startIndex = text.IndexOf(" ", StringComparison.Ordinal) + 1;
			string text5 = text.Substring(startIndex);
			if (array[0] == "/kick")
			{
				foreach (Client value in Server.clients.Values)
				{
					if (value != null && value.player != null && value.player.username.ToLower().Contains(text5.ToLower()))
					{
						___suggestedText = array[0] + " ";
						___suggestedText += value.player.username;
						break;
					}
				}
			}
			return false;
		}
	}
}
namespace SuperMuckApi.Achievements
{
	public class Achievement
	{
		public string name = "Custom Achievement";

		public string description = "Custom Achievement Description.";

		public Sprite icon;

		public bool Unlocked = false;

		public Achievement(string name, string description, Sprite icon)
		{
			this.name = name;
			this.description = description;
			this.icon = icon;
		}
	}
	internal class AchievementAnimation : MonoBehaviour
	{
		private bool Retrocess = false;

		public void Awake()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject, 3f);
		}

		public void Update()
		{
		}
	}
	public static class CustomAchievementManager
	{
		public static readonly Dictionary<string, Achievement> Achievements = new Dictionary<string, Achievement>();

		internal static void InitAchievementManager()
		{
			RegisterAchievement(new Achievement("Jump", "I can jump.", null));
			ResetAchievements();
		}

		public static void RegisterAchievement(Achievement achievement)
		{
			if (PlayerPrefs.HasKey(achievement.name))
			{
				achievement.Unlocked = ((PlayerPrefs.GetInt(achievement.name) != 0) ? true : false);
				Achievements.Add(achievement.name, achievement);
			}
			else
			{
				PlayerPrefs.SetInt(achievement.name, 0);
				Achievements.Add(achievement.name, achievement);
			}
		}

		public static bool UnlockAchievement(string name)
		{
			Console.WriteLine("A");
			if (!Achievements.ContainsKey(name) || (Object)(object)GameObject.Find("UI (1)") == (Object)null)
			{
				return false;
			}
			Console.WriteLine(Achievements[name].Unlocked);
			if (!Achievements[name].Unlocked)
			{
				Console.WriteLine("Unlocking");
				Achievements[name].Unlocked = true;
				PlayerPrefs.SetInt(name, 1);
				Console.WriteLine("Creating achievement alert");
				Console.WriteLine("Setting icon");
				if ((Object)(object)Achievements[name].icon != (Object)null)
				{
				}
				Console.WriteLine("Setting text");
				return true;
			}
			return false;
		}

		public static void ResetAchievements()
		{
			foreach (Achievement value in Achievements.Values)
			{
				value.Unlocked = false;
				PlayerPrefs.SetInt(value.name, 0);
			}
		}
	}
}

using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Better_Item_Pickup")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Better_Item_Pickup")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a4a9bd62-94fd-4df0-a9a5-5c6eb06c9798")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Better_Item_Pickup
{
	[BepInPlugin("GoldenGuy1000.Better_Item_Pickup", "Better_Item_Pickup", "1.0.0.0")]
	public class Main : BaseUnityPlugin
	{
		public const string MODNAME = "Better_Item_Pickup";

		public const string AUTHOR = "GoldenGuy1000";

		public const string GUID = "GoldenGuy1000.Better_Item_Pickup";

		public const string VERSION = "1.0.0.0";

		internal readonly ManualLogSource log;

		internal readonly Harmony harmony;

		internal readonly Assembly assembly;

		public readonly string modFolder;

		public Main()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			log = ((BaseUnityPlugin)this).Logger;
			harmony = new Harmony("GoldenGuy1000.Better_Item_Pickup");
			assembly = Assembly.GetExecutingAssembly();
			modFolder = Path.GetDirectoryName(assembly.Location);
		}

		public void Start()
		{
			harmony.PatchAll(assembly);
		}
	}
}
namespace Better_Item_Pickup.Patches
{
	[HarmonyPatch(typeof(InventoryUI), "FillCellList")]
	public static class Patches
	{
		[HarmonyPrefix]
		public static bool hotbarFirst(InventoryUI __instance)
		{
			__instance.cells = new List<InventoryCell>();
			InventoryCell[] componentsInChildren = ((Component)__instance.hotkeysTransform).GetComponentsInChildren<InventoryCell>();
			foreach (InventoryCell item in componentsInChildren)
			{
				__instance.cells.Add(item);
			}
			componentsInChildren = ((Component)__instance.inventoryParent).GetComponentsInChildren<InventoryCell>();
			foreach (InventoryCell item2 in componentsInChildren)
			{
				__instance.cells.Add(item2);
			}
			return false;
		}
	}
}

using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("DPSMeter")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("DPSMeter")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("0df5918f-f8b3-44b7-aeb2-4e5ea72e2b20")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace DPSMeter;

internal class DPSMeter : MonoBehaviour
{
	public static DPSMeter instance;

	private const float highDamage = 1000f;

	private Gradient dpsColor;

	private float dps = 0f;

	private float combatTime = 0f;

	private float timeSinceCombat = 1000f;

	public TextMeshProUGUI text;

	public void AddDamage(int damage)
	{
		dps += damage;
		timeSinceCombat = 0f;
	}

	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_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_006d: 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_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: 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_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
		if (Object.op_Implicit((Object)(object)instance))
		{
			Object.Destroy((Object)(object)this);
		}
		else
		{
			instance = this;
		}
		text = ((Component)this).gameObject.GetComponent<TextMeshProUGUI>();
		dpsColor = new Gradient();
		dpsColor.SetKeys((GradientColorKey[])(object)new GradientColorKey[4]
		{
			new GradientColorKey(Color.white, 0f),
			new GradientColorKey(Color.white, 0.3f),
			new GradientColorKey(Color.yellow, 0.7f),
			new GradientColorKey(Color.red, 1f)
		}, (GradientAlphaKey[])(object)new GradientAlphaKey[2]
		{
			new GradientAlphaKey(1f, 0f),
			new GradientAlphaKey(1f, 1f)
		});
	}

	private void Update()
	{
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		timeSinceCombat += Time.deltaTime;
		if (timeSinceCombat > 10f)
		{
			combatTime = 0f;
			dps = 0f;
			((Behaviour)text).enabled = false;
		}
		else
		{
			combatTime += Time.deltaTime;
			((Behaviour)text).enabled = true;
			float num = dps / combatTime;
			((TMP_Text)text).text = "DPS: " + num.ToString("N0");
			((Graphic)text).color = dpsColor.Evaluate(num / 1000f);
		}
	}
}
[BepInPlugin("Isse.DPSMeter", "DPSMeter", "1.0.1.0")]
public class MainClass : BaseUnityPlugin
{
	public const string Name = "DPSMeter";

	public const string Author = "Isse";

	public const string Guid = "Isse.DPSMeter";

	public const string Version = "1.0.1.0";

	public static MainClass instance;

	public Harmony harmony;

	public ManualLogSource log;

	private void Awake()
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Expected O, but got Unknown
		if (!Object.op_Implicit((Object)(object)instance))
		{
			instance = this;
		}
		else
		{
			Object.Destroy((Object)(object)this);
		}
		log = ((BaseUnityPlugin)this).Logger;
		harmony = new Harmony("Isse.DPSMeter");
		harmony.PatchAll();
	}
}
[HarmonyPatch(typeof(ClientSend))]
public class ClientSendPatch
{
	[HarmonyPatch("PlayerDamageMob")]
	[HarmonyPrefix]
	public static void Mob(ClientSend __instance, int damage)
	{
		if (Object.op_Implicit((Object)(object)DPSMeter.instance))
		{
			DPSMeter.instance.AddDamage(damage);
		}
	}

	[HarmonyPatch("PlayerHitObject")]
	[HarmonyPrefix]
	public static void Object(ClientSend __instance, int damage)
	{
		if (Object.op_Implicit((Object)(object)DPSMeter.instance))
		{
			DPSMeter.instance.AddDamage(damage);
		}
	}
}
[HarmonyPatch(typeof(StatusUI))]
public class StatusUIPatch
{
	[HarmonyPatch("Start")]
	[HarmonyPostfix]
	public static void Start(StatusUI __instance)
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = Object.Instantiate<GameObject>(((Component)__instance.hpText).gameObject, ((TMP_Text)__instance.hpText).transform.parent);
		((Object)val.gameObject).name = "DPSMeter";
		Transform transform = val.transform;
		transform.position += new Vector3(30f, 60f);
		val.AddComponent<DPSMeter>();
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ItemStatDisplay")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ItemStatDisplay")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("968239fc-af9c-4138-aa61-2e40984fc893")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ItemStatDisplay;

[BepInPlugin("Isse.ItemStatDisplay", "ItemStatDisplay", "1.1.0.0")]
public class MainClass : BaseUnityPlugin
{
	public const string Name = "ItemStatDisplay";

	public const string Author = "Isse";

	public const string Guid = "Isse.ItemStatDisplay";

	public const string Version = "1.1.0.0";

	public static MainClass instance;

	public Harmony harmony;

	public ManualLogSource log;

	public ConfigEntry<KeyCode> extraInfoKeybind;

	private void Awake()
	{
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Expected O, but got Unknown
		if (!Object.op_Implicit((Object)(object)instance))
		{
			instance = this;
		}
		else
		{
			Object.Destroy((Object)(object)this);
		}
		extraInfoKeybind = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Keybinds", "ExtraInfoKey", (KeyCode)304, "Key to show even more extra info when hovering. (This is not implemented by the base mod)");
		log = ((BaseUnityPlugin)this).Logger;
		harmony = new Harmony("Isse.ItemStatDisplay");
		harmony.PatchAll(typeof(Helper));
		harmony.PatchAll(typeof(ExtraItemInfo));
		harmony.PatchAll(typeof(ExtraPowerupInfo));
	}

	private void Update()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		if (Input.GetKeyDown(extraInfoKeybind.Value))
		{
			ExtraPowerupInfo.showExtraInfo = true;
			if (Object.op_Implicit((Object)(object)ExtraPowerupInfo.current))
			{
				ExtraPowerupInfo.current.OnPointerEnter((PointerEventData)null);
			}
		}
		if (Input.GetKeyUp(extraInfoKeybind.Value))
		{
			ExtraPowerupInfo.showExtraInfo = false;
			if (Object.op_Implicit((Object)(object)ExtraPowerupInfo.current))
			{
				ExtraPowerupInfo.current.OnPointerEnter((PointerEventData)null);
			}
		}
	}

	private void RegisterPowerUp(Tuple<string, Func<int, bool, string>> def)
	{
		ExtraPowerupInfo.Add(def.Item1, def.Item2);
	}
}
public static class Helper
{
	public static float CD(int count, float scaleSpeed, float maxValue)
	{
		float num = 2.71828f;
		return (1f - Mathf.Pow(num, (0f - (float)count) * scaleSpeed)) * maxValue;
	}

	public static string Percent(float f)
	{
		return (f * 100f).ToString("N0") + "%";
	}
}
public static class ExtraItemInfo
{
	[HarmonyPatch(typeof(InventoryCell), "OnPointerEnter")]
	[HarmonyPostfix]
	private static void PostFix(InventoryCell __instance)
	{
		//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_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Invalid comparison between Unknown and I4
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		//IL_026e: Invalid comparison between Unknown and I4
		//IL_0384: Unknown result type (might be due to invalid IL or missing references)
		//IL_038a: Invalid comparison between Unknown and I4
		if (!Object.op_Implicit((Object)(object)__instance.currentItem))
		{
			return;
		}
		Vector2 dmgRange = Traverse.Create<PowerupCalculations>().Field<Vector2>("randomDamageRange").Value;
		if (Object.op_Implicit((Object)(object)__instance.currentItem.bowComponent) && (int)__instance.currentItem.type == 9)
		{
			if (__instance.currentItem.attackDamage != 1)
			{
				TextMeshProUGUI text = ItemInfo.Instance.text;
				((TMP_Text)text).text = ((TMP_Text)text).text + "\n x" + DmgRange(__instance.currentItem.attackDamage) + " damage to mobs";
			}
			TextMeshProUGUI text2 = ItemInfo.Instance.text;
			((TMP_Text)text2).text = ((TMP_Text)text2).text + "\n " + __instance.currentItem.attackSpeed + " attack speed";
			if (__instance.currentItem.bowComponent.nArrows > 1)
			{
				TextMeshProUGUI text3 = ItemInfo.Instance.text;
				((TMP_Text)text3).text = ((TMP_Text)text3).text + "\n fires " + __instance.currentItem.bowComponent.nArrows + " arrows";
			}
			TextMeshProUGUI text4 = ItemInfo.Instance.text;
			((TMP_Text)text4).text = ((TMP_Text)text4).text + "\n" + __instance.currentItem.bowComponent.projectileSpeed + " projectile speed";
		}
		else if (__instance.currentItem.attackDamage > 1)
		{
			TextMeshProUGUI text5 = ItemInfo.Instance.text;
			((TMP_Text)text5).text = ((TMP_Text)text5).text + "\n " + DmgRange(__instance.currentItem.attackDamage) + " damage to mobs";
			TextMeshProUGUI text6 = ItemInfo.Instance.text;
			((TMP_Text)text6).text = ((TMP_Text)text6).text + "\n " + __instance.currentItem.attackSpeed + " attack speed";
		}
		if (__instance.currentItem.attackRange > 1f)
		{
			TextMeshProUGUI text7 = ItemInfo.Instance.text;
			((TMP_Text)text7).text = ((TMP_Text)text7).text + "\n +" + __instance.currentItem.attackRange + " range";
		}
		if (__instance.currentItem.resourceDamage > 1)
		{
			TextMeshProUGUI text8 = ItemInfo.Instance.text;
			((TMP_Text)text8).text = ((TMP_Text)text8).text + "\n " + DmgRange(__instance.currentItem.resourceDamage) + " damage to " + (((int)__instance.currentItem.type == 2) ? "rocks" : "trees");
		}
		if (Object.op_Implicit((Object)(object)__instance.currentItem.fuel))
		{
			TextMeshProUGUI text8 = ItemInfo.Instance.text;
			((TMP_Text)text8).text = ((TMP_Text)text8).text + "\ncan smelt " + __instance.currentItem.fuel.maxUses + " item" + ((__instance.currentItem.fuel.maxUses > 1) ? "s" : "");
		}
		if (__instance.currentItem.processable)
		{
			TextMeshProUGUI text8 = ItemInfo.Instance.text;
			((TMP_Text)text8).text = ((TMP_Text)text8).text + "\nSmelts in " + __instance.currentItem.processTime + " second" + ((__instance.currentItem.processTime != 1f) ? "s" : "");
		}
		if ((int)__instance.currentItem.tag == 2)
		{
			if (__instance.currentItem.heal > 0f)
			{
				TextMeshProUGUI text9 = ItemInfo.Instance.text;
				((TMP_Text)text9).text = ((TMP_Text)text9).text + "\n +" + __instance.currentItem.heal + " health";
			}
			if (__instance.currentItem.stamina > 0f)
			{
				TextMeshProUGUI text10 = ItemInfo.Instance.text;
				((TMP_Text)text10).text = ((TMP_Text)text10).text + "\n +" + __instance.currentItem.stamina + " stamina";
			}
			if (__instance.currentItem.hunger > 0f)
			{
				TextMeshProUGUI text11 = ItemInfo.Instance.text;
				((TMP_Text)text11).text = ((TMP_Text)text11).text + "\n +" + __instance.currentItem.hunger + " hunger";
			}
		}
		string DmgRange(float dmg)
		{
			return dmg * dmgRange.x + "-" + dmg * dmgRange.y;
		}
	}
}
public static class ExtraPowerupInfo
{
	private static Dictionary<string, Func<int, bool, string>> infoFunctions;

	public static PowerupInfo current;

	public static bool showExtraInfo;

	static ExtraPowerupInfo()
	{
		infoFunctions = new Dictionary<string, Func<int, bool, string>>();
		AddDefault();
	}

	private static void AddDefault()
	{
		Add("Dumbbell", (int count, bool _) => "+" + Helper.Percent((float)count * 0.1f) + " strength");
		Add("Berserk", (int count, bool _) => "+" + Helper.Percent((float)count * 0.01f) + " strength per % of missing hp");
		Add("Peanut Butter", (int count, bool _) => "+" + Helper.Percent((float)count * 0.15f) + " stamina");
		Add("Adrenaline", (int count, bool _) => "Gain " + Helper.Percent(Helper.CD(count, 1f, 2f)) + " stamina, movementspeed and attackspeed for 5 seconds");
		Add("Sneaker", (int count, bool _) => Helper.Percent(1f + Helper.CD(count, 0.08f, 1.75f)) + " movement speed");
		Add("Sniper Scope", (int count, bool _) => Helper.Percent(Helper.CD(count, 0.14f, 0.15f)) + " chance to deal " + Helper.Percent(Helper.CD(count, 0.25f, 50f)) + " damage");
		Add("Blue Pill", (int count, bool _) => "+" + count * 10 + " shield");
		Add("Robin Hood Hat", (int count, bool _) => Helper.Percent(1f + Helper.CD(count, 0.06f, 2f)) + " faster bow draw speed, faster arrow speed and arrow damage");
		Add("Checkered Shirt", (int count, bool _) => Helper.Percent(1f + Helper.CD(count, 0.3f, 4f)) + " resource damage");
		Add("Dracula", (int count, bool _) => "Gain " + count + " max hp on kill, stacks up to " + count * 40 + " bonus max hp");
		Add("Piggybank", (int count, bool _) => Helper.Percent(1f + Helper.CD(count, 0.15f, 1.25f)) + " loot dropped from mobs and resources");
		Add("Knuts Hammer", (int count, bool _) => Helper.Percent(Helper.CD(count, 0.12f, 0.4f)) + " chance to summon lightning that deals +" + Helper.Percent(2f + Helper.CD(count, 0.12f, 1f)) + " of the damage dealt");
		Add("Crimson Dagger", (int count, bool _) => "Heal for " + Helper.Percent(Helper.CD(count, 0.1f, 0.5f)) + " of damage dealt");
		Add("Bulldozer", (int count, bool _) => Helper.Percent(Helper.CD(count, 0.15f, 1f)) + " chance to knock back target");
		Add("Jetpack", (int count, bool _) => Helper.Percent(1f + Helper.CD(count, 0.075f, 2.5f)) + " jump height");
		Add("Juice", (int count, bool _) => Helper.Percent(1f + Helper.CD(count, 0.3f, 1f)) + " attack speed for 2 seconds after a crit");
		Add("Spooo Bean", (int count, bool _) => Helper.Percent(1f - Helper.CD(count, 0.2f, 0.5f)) + " hunger drain");
		Add("Red Pill", (int count, bool _) => "+" + count * 10 + " max hp");
		Add("Broccoli", (int count, bool _) => 100 + count * 5 + "% healing");
		Add("Wings of Glory", (int count, bool _) => Helper.Percent(1f + Helper.CD(count, 0.45f, 2.5f)) + " damage while falling");
		Add("Janniks Frog", (int count, bool _) => count + " extra jumps");
		Add("Enforcer", (int count, bool _) => "+" + (5f * Helper.CD(count, 0.4f, 2f)).ToString("N1") + "% damage for each unit moved per second");
		Add("Danis Milk", (int count, bool _) => "+" + Helper.CD(count, 0.1f, 40f).ToString("N1") + " bonus armor");
		Add("Horseshoe", (int count, bool _) => "+" + Helper.Percent(Helper.CD(count, 0.08f, 0.9f)) + " crit chance");
		Add("Orange Juice", (int count, bool _) => Helper.Percent(1f + Helper.CD(count, 0.12f, 1f)) + " attack speed");
	}

	public static void Add(string name, Func<int, bool, string> function)
	{
		if (infoFunctions.ContainsKey(name))
		{
			MainClass.instance.log.LogMessage((object)("Override powerup: " + name));
			infoFunctions[name] = function;
		}
		else
		{
			MainClass.instance.log.LogMessage((object)("Add powerup: " + name));
			infoFunctions.Add(name, function);
		}
	}

	private static int Count(string name)
	{
		return Traverse.Create((object)PowerupInventory.Instance).Field<int[]>("powerups").Value[ItemManager.Instance.stringToPowerupId[name]];
	}

	private static string GetStatInfo(string name, bool extraInfo)
	{
		if (infoFunctions.TryGetValue(name, out var value))
		{
			return value(Count(name), extraInfo);
		}
		return "NOT IMPLEMENTED";
	}

	[HarmonyPatch(typeof(PowerupInfo), "OnPointerEnter")]
	[HarmonyPostfix]
	private static void OnPointerEnter(PowerupInfo __instance)
	{
		current = __instance;
		TextMeshProUGUI text = ItemInfo.Instance.text;
		((TMP_Text)text).text = ((TMP_Text)text).text + "</i></size>\n\n<size=60%>" + GetStatInfo(__instance.powerup.name, showExtraInfo);
	}

	[HarmonyPatch(typeof(PowerupInfo), "OnPointerExit")]
	[HarmonyPostfix]
	private static void OnPointerExit(PowerupInfo __instance)
	{
		current = null;
	}
}