using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("my.pahsiv.MyFoodAirlines")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.1.0")]
[assembly: AssemblyInformationalVersion("0.1.1")]
[assembly: AssemblyProduct("my.pahsiv.MyFoodAirlines")]
[assembly: AssemblyTitle("MyFoodAirlines")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace MyFoodAirlines
{
	public static class ColoredLogging
	{
		private static readonly MethodInfo SetConsoleColorMethod;

		private static readonly TextWriter ConsoleStream;

		static ColoredLogging()
		{
			Assembly assembly = typeof(BaseUnityPlugin).Assembly;
			Type type = assembly.GetType("BepInEx.ConsoleManager");
			if (type != null)
			{
				SetConsoleColorMethod = type.GetMethod("SetConsoleColor", BindingFlags.Static | BindingFlags.Public);
				ConsoleStream = type.GetProperty("ConsoleStream", BindingFlags.Static | BindingFlags.Public)?.GetValue(null) as TextWriter;
			}
		}

		private static void SetColor(ConsoleColor color)
		{
			SetConsoleColorMethod?.Invoke(null, new object[1] { color });
		}

		private static void WriteColored(string message, ConsoleColor color, bool newline = true)
		{
			if (ConsoleStream != null)
			{
				SetColor(color);
				if (newline)
				{
					ConsoleStream.WriteLine(message);
				}
				else
				{
					ConsoleStream.Write(message);
				}
				SetColor(ConsoleColor.Gray);
			}
		}

		public static void LogColor(this ManualLogSource log, string message, ConsoleColor color = ConsoleColor.Gray)
		{
			WriteColored(message, color);
		}

		public static void LogColorW(this ManualLogSource log, string message, ConsoleColor color = ConsoleColor.Yellow)
		{
			WriteColored(message, color);
		}

		public static void LogColorE(this ManualLogSource log, string message, ConsoleColor color = ConsoleColor.Red)
		{
			WriteColored(message, color);
		}

		public static void LogColorS(this ManualLogSource log, string message, ConsoleColor color = ConsoleColor.Green)
		{
			WriteColored(message, color);
		}

		public static void LogColorM(this ManualLogSource log, string message, ConsoleColor color = ConsoleColor.Magenta)
		{
			WriteColored(message, color);
		}

		public static void LogColorC(this ManualLogSource log, string message, ConsoleColor color = ConsoleColor.Cyan)
		{
			WriteColored(message, color);
		}
	}
	public static class ColorHelper
	{
		public const string White = "FFFFFF";

		public const string Black = "000000";

		public const string Red = "FF0000";

		public const string Green = "00FF00";

		public const string Blue = "0000FF";

		public const string Yellow = "FFFF00";

		public const string Purple = "8765CA";

		public const string Gray = "808080";

		public const string Orange = "FFA500";

		public const string Cyan = "00FFFF";

		public const string Magenta = "FF00FF";

		public const string Pink = "FFC0CB";

		public const string Brown = "A52A2A";

		public const string Lime = "00FF00";

		public const string Teal = "008080";

		public const string Navy = "000080";

		public const string Maroon = "800000";

		public const string Olive = "808000";

		public const string Aqua = "00FFFF";

		public const string Silver = "C0C0C0";

		public const string Gold = "FFD700";

		public const string LightRed = "FF6B6B";

		public const string LightGreen = "90EE90";

		public const string LightBlue = "ADD8E6";

		public const string LightGray = "D3D3D3";

		public const string LightPink = "FFB6C1";

		public const string DarkRed = "8B0000";

		public const string DarkGreen = "006400";

		public const string DarkBlue = "00008B";

		public const string DarkGray = "A9A9A9";

		public const string DarkOrange = "FF8C00";

		public const string Pahsiv = "3582E7";
	}
	internal class Patch
	{
		[HarmonyPatch(typeof(Item), "RPC_SetThrownData")]
		public class RPC_SetThrownDataPatch
		{
			[HarmonyPrefix]
			public static void Prefix(Item __instance, int characterID, float thrownAmount)
			{
				if (!PhotonNetwork.IsMasterClient || thrownAmount < 0.9f || !Plugin.EnableMod.Value || !ThrownItemCollisionDetector.IsWhitelistedItem(__instance))
				{
					return;
				}
				string text = Utilities.AddColor("[" + Plugin.Name + "]", "3582E7");
				string text2 = Utilities.AddColor(((Object)__instance).name.Replace("(Clone)", ""), "00FF00");
				if (Plugin.DisableBookOfBones.Value && __instance.itemID == 115)
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisableCursedSkull.Value && __instance.itemID == 25)
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisablePandorasBox.Value && __instance.itemID == 58)
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisableNapberry.Value && __instance.itemID == 110)
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisableShroomberry.Value && ThrownItemCollisionDetector.IsShroomberries(__instance))
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisableMandrake.Value && __instance.itemID == 155)
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisableHealing.Value && ThrownItemCollisionDetector.IsHealingItem(__instance))
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisableLollipop.Value && __instance.itemID == 44)
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisableEnergyDrink.Value && __instance.itemID == 27)
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisablePepperBerry.Value && __instance.itemID == 60)
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				if (Plugin.DisableFlare.Value && __instance.itemID == 32)
				{
					if (Plugin.ShowForceFeedMessage.Value)
					{
						Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
					}
					return;
				}
				PhotonView photonView = PhotonNetwork.GetPhotonView(characterID);
				Character thrower = default(Character);
				if (!((Object)(object)photonView == (Object)null) && ((Component)photonView).TryGetComponent<Character>(ref thrower))
				{
					ThrownItemCollisionDetector thrownItemCollisionDetector = ((Component)__instance).gameObject.AddComponent<ThrownItemCollisionDetector>();
					thrownItemCollisionDetector.Initialize(thrower);
				}
			}
		}
	}
	[BepInPlugin("my.pahsiv.MyFoodAirlines", "MyFoodAirlines", "0.1.1")]
	public class Plugin : BaseUnityPlugin
	{
		public static ConfigEntry<bool> EnableMod;

		public static ConfigEntry<bool> DisableBookOfBones;

		public static ConfigEntry<bool> DisableCursedSkull;

		public static ConfigEntry<bool> DisablePandorasBox;

		public static ConfigEntry<bool> DisableNapberry;

		public static ConfigEntry<bool> DisableShroomberry;

		public static ConfigEntry<bool> DisablePoisonFood;

		public static ConfigEntry<bool> DisableIncineratedFood;

		public static ConfigEntry<bool> DisableMandrake;

		public static ConfigEntry<bool> DisableFlare;

		public static ConfigEntry<bool> DisableHealing;

		public static ConfigEntry<bool> DisableLollipop;

		public static ConfigEntry<bool> DisableEnergyDrink;

		public static ConfigEntry<bool> DisablePepperBerry;

		public static ConfigEntry<bool> ShowForceFeedMessage;

		public const string Id = "my.pahsiv.MyFoodAirlines";

		internal static ManualLogSource Log { get; private set; }

		public static Plugin Instance { get; private set; }

		public static string Name => "MyFoodAirlines";

		public static string Version => "0.1.1";

		private void Awake()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			Log.LogColorM("          Plugin " + Name + " " + Version + " is loading...");
			Harmony val = new Harmony("my.pahsiv.MyFoodAirlines");
			val.PatchAll();
			Utilities.VerifyPatch(val);
			BindConfig();
			Log.LogColorC("          Plugin " + Name + " " + Version + " is loaded!");
		}

		private void BindConfig()
		{
			EnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Master Switch", true, "Enable or disable all features of this plugin.");
			DisableBookOfBones = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Book Of Bones", true, "Disable the usage of Book Of Bones.");
			DisableCursedSkull = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Cursed Skull", true, "Disable the usage of Cursed Skull.");
			DisablePandorasBox = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Pandoras Lunchbox", true, "Disable the usage of Pandoras Lunchbox.");
			DisableNapberry = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Napberry", true, "Disable the usage of Napberry.");
			DisableIncineratedFood = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Incinerated Food", true, "Disable the usage of Incinerated Food.");
			DisableFlare = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Flare", true, "Disable the usage of Flare.");
			DisablePoisonFood = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Poisonous Food", false, "Disable the usage of Poisonous Food.");
			DisableShroomberry = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Shroomberries", false, "Disable the usage of Shroomberries.");
			DisableMandrake = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Mandrake", false, "Disable the usage of Mandrake.");
			DisableHealing = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Healing Items", false, "Disable the usage of Healing Items.");
			DisableLollipop = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Lollipop", false, "Disable the usage of Lollipop.");
			DisableEnergyDrink = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Energy Drink", false, "Disable the usage of Energy Drink.");
			DisablePepperBerry = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Disable Pepper Berry", false, "Disable the usage of Pepper Berry.");
			ShowForceFeedMessage = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Show Force Feed Message", false, "Display the Force Feed Notification.");
		}
	}
	public class ThrownItemCollisionDetector : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <CleanupItemAfterFrames>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public int framesToWait;

			public Item item;

			public ThrownItemCollisionDetector <>4__this;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CleanupItemAfterFrames>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				ThrownItemCollisionDetector thrownItemCollisionDetector = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < framesToWait)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if ((Object)(object)item == (Object)null)
				{
					return false;
				}
				if ((thrownItemCollisionDetector.GetItemUses(item) <= 0 || thrownItemCollisionDetector.GetUseRemainingPercentage(item) <= 0f) && PhotonNetwork.IsMasterClient)
				{
					PhotonNetwork.Destroy(((Component)item).GetComponent<PhotonView>());
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static HashSet<int> thrownItemPhotonIDs = new HashSet<int>();

		private Character throwerCharacter;

		private bool hasHit;

		private float creationTime;

		private const float DETECTION_TIMEOUT = 5f;

		private static readonly HashSet<int> WhitelistedItemIDs = new HashSet<int>
		{
			0, 101, 3, 4, 5, 105, 37, 7, 9, 10,
			11, 12, 115, 95, 19, 20, 21, 22, 25, 26,
			114, 27, 29, 32, 152, 154, 33, 35, 55, 38,
			56, 40, 41, 42, 43, 44, 155, 156, 46, 81,
			83, 84, 88, 89, 93, 97, 102, 110, 58, 59,
			60, 103, 108, 111, 66, 158, 159, 160, 161, 162,
			71, 104, 109, 73, 75, 76
		};

		private static readonly HashSet<int> Poison = new HashSet<int> { 3, 56, 41, 84, 89, 97 };

		private static readonly HashSet<int> Shroomberries = new HashSet<int> { 158, 159, 160, 161, 162 };

		private static readonly HashSet<int> HealingItem = new HashSet<int> { 7, 29 };

		private static readonly HashSet<int> ItemUses = new HashSet<int> { 115, 58, 66 };

		public void Initialize(Character thrower)
		{
			throwerCharacter = thrower;
			creationTime = Time.time;
			PhotonView component = ((Component)this).GetComponent<PhotonView>();
			if ((Object)(object)component != (Object)null)
			{
				thrownItemPhotonIDs.Add(component.ViewID);
			}
		}

		private void OnCollisionEnter(Collision collision)
		{
			if (hasHit)
			{
				return;
			}
			if (Time.time - creationTime > 5f)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			Character componentInParent = collision.gameObject.GetComponentInParent<Character>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				hasHit = true;
				Object.Destroy((Object)(object)this);
				return;
			}
			bool flag = (Object)(object)componentInParent == (Object)(object)throwerCharacter;
			float num = Time.time - creationTime;
			if (!flag || !(num < 0.5f))
			{
				hasHit = true;
				ForceFeedCharacter(componentInParent);
				Object.Destroy((Object)(object)this);
			}
		}

		private void ForceFeedCharacter(Character targetCharacter)
		{
			Item component = ((Component)this).GetComponent<Item>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			string text = Utilities.AddColor("[" + Plugin.Name + "]", "3582E7");
			if (Plugin.DisableIncineratedFood.Value && GetCookedAmount(component) >= 4)
			{
				if (Plugin.ShowForceFeedMessage.Value)
				{
					string text2 = Utilities.AddColor("Incinerated Food", "00FF00");
					Utilities.Notification(text + " " + text2 + " disabled!", "FFFF00");
				}
				return;
			}
			if (Plugin.DisablePoisonFood.Value && IsPoisonous(component) && GetCookedAmount(component) <= 0)
			{
				if (Plugin.ShowForceFeedMessage.Value)
				{
					string text3 = Utilities.AddColor("Poisonous Food", "00FF00");
					Utilities.Notification(text + " " + text3 + " disabled!", "FFFF00");
				}
				return;
			}
			if ((Object)(object)component.lastThrownCharacter != (Object)null)
			{
				Plugin.Log.LogColorM($"{component.lastThrownCharacter.characterName}     -- [{((Object)component).name}] [{GetCookedAmount(component)}]-->     {targetCharacter.characterName}");
			}
			if (HasItemUses(component) && (GetItemUses(component) <= 0 || GetUseRemainingPercentage(component) <= 0f))
			{
				if (PhotonNetwork.IsMasterClient)
				{
					PhotonNetwork.Destroy(((Component)component).GetComponent<PhotonView>());
				}
				return;
			}
			if (Plugin.ShowForceFeedMessage.Value && (Object)(object)component.lastThrownCharacter != (Object)null)
			{
				string text4 = Utilities.AddColor(component.lastThrownCharacter.characterName, "FFC0CB");
				string text5 = Utilities.AddColor(((Object)component).name.Replace("(Clone)", ""), "00FF00");
				string text6 = Utilities.AddColor(targetCharacter.characterName, "00FFFF");
				Utilities.Notification(text4 + "   - [" + text5 + "] ->   " + text6, "FFFF00");
			}
			targetCharacter.FeedItem(component);
			if (HasItemUses(component))
			{
				((MonoBehaviour)component).StartCoroutine(CleanupItemAfterFrames(component, 30));
			}
		}

		[IteratorStateMachine(typeof(<CleanupItemAfterFrames>d__8))]
		private IEnumerator CleanupItemAfterFrames(Item item, int framesToWait)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CleanupItemAfterFrames>d__8(0)
			{
				<>4__this = this,
				item = item,
				framesToWait = framesToWait
			};
		}

		private void LogItemData(StreamWriter writer, Item item, DataEntryKey key, string keyName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!item.HasData(key))
			{
				return;
			}
			try
			{
				string dataValueAsString = GetDataValueAsString(item, key);
				writer.WriteLine("            " + keyName + " : " + dataValueAsString);
			}
			catch (Exception ex)
			{
				writer.WriteLine("            " + keyName + " : Error reading data - " + ex.Message);
			}
		}

		private string GetDataValueAsString(Item item, DataEntryKey key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected I4, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			switch ((int)key)
			{
			case 0:
			case 1:
			case 6:
			case 9:
			{
				IntItemData data4 = item.GetData<IntItemData>(key);
				return data4.Value.ToString();
			}
			case 2:
			{
				OptionableIntItemData data3 = item.GetData<OptionableIntItemData>(key);
				return data3.Value.ToString();
			}
			case 3:
			case 5:
			case 8:
			{
				BoolItemData data2 = item.GetData<BoolItemData>(key);
				return data2.Value.ToString();
			}
			case 10:
			case 11:
			case 13:
			case 14:
			{
				FloatItemData data = item.GetData<FloatItemData>(key);
				return data.Value.ToString();
			}
			default:
				return "Unknown type";
			}
		}

		private int GetItemUses(Item item)
		{
			OptionableIntItemData data = item.GetData<OptionableIntItemData>((DataEntryKey)2);
			return data.Value;
		}

		private int GetCookedAmount(Item item)
		{
			IntItemData data = item.GetData<IntItemData>((DataEntryKey)1);
			return data.Value;
		}

		private float GetUseRemainingPercentage(Item item)
		{
			FloatItemData data = item.GetData<FloatItemData>((DataEntryKey)11);
			return data.Value;
		}

		private void Update()
		{
			if (Time.time - creationTime > 5f)
			{
				Object.Destroy((Object)(object)this);
			}
		}

		private void OnDestroy()
		{
			PhotonView component = ((Component)this).GetComponent<PhotonView>();
			if ((Object)(object)component != (Object)null)
			{
				thrownItemPhotonIDs.Remove(component.ViewID);
			}
		}

		public static bool IsMaxChargeThrown(Item item)
		{
			PhotonView component = ((Component)item).GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			return thrownItemPhotonIDs.Contains(component.ViewID);
		}

		public static bool IsWhitelistedItem(Item item)
		{
			return WhitelistedItemIDs.Contains(item.itemID);
		}

		public static bool IsPoisonous(Item item)
		{
			return Poison.Contains(item.itemID);
		}

		public static bool IsShroomberries(Item item)
		{
			return Shroomberries.Contains(item.itemID);
		}

		public static bool IsHealingItem(Item item)
		{
			return HealingItem.Contains(item.itemID);
		}

		public static bool HasItemUses(Item item)
		{
			return ItemUses.Contains(item.itemID);
		}
	}
	public static class Utilities
	{
		public static void VerifyPatch(Harmony harmony)
		{
			IEnumerable<MethodBase> patchedMethods = harmony.GetPatchedMethods();
			Plugin.Log.LogMessage((object)$"          Total patched methods: {patchedMethods.Count()}");
			foreach (MethodBase item in patchedMethods)
			{
				Plugin.Log.LogMessage((object)("          Patched: " + item.DeclaringType?.Name + "." + item.Name));
			}
		}

		public static void Notification(string message, string color = "FFFFFF", bool sound = false)
		{
			//IL_0086: 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)
			PlayerConnectionLog val = Object.FindFirstObjectByType<PlayerConnectionLog>();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			string text = "<color=#" + color + ">" + message + "</color>";
			MethodInfo method = typeof(PlayerConnectionLog).GetMethod("AddMessage", BindingFlags.Instance | BindingFlags.NonPublic);
			if (method != null)
			{
				method.Invoke(val, new object[1] { text });
				if ((Object)(object)val.sfxJoin != (Object)null && sound)
				{
					val.sfxJoin.Play(default(Vector3));
				}
			}
			else
			{
				Plugin.Log.LogWarning((object)"AddMessage method not found.");
			}
		}

		public static string AddColor(string text, string color)
		{
			return "<color=#" + color + ">" + text + "</color>";
		}

		public static string ConvertKeyCodeToInputPath(KeyCode keyCode)
		{
			string text = ((object)(KeyCode)(ref keyCode)).ToString();
			if (text.StartsWith("Keypad"))
			{
				text = text.Replace("Keypad", "numpad");
			}
			return "<Keyboard>/" + text.ToLower();
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}