using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;
using Zorro.Core;
using Zorro.Core.Serizalization;

[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.MyBackpackAlert")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.2.0")]
[assembly: AssemblyInformationalVersion("0.1.2")]
[assembly: AssemblyProduct("my.pahsiv.MyBackpackAlert")]
[assembly: AssemblyTitle("MyBackpackAlert")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
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")]
	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")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace MyBackpackAlert
{
	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(Player), "SyncInventoryRPC")]
		public class SyncInventoryRPC_Patch
		{
			[HarmonyPostfix]
			public static void Postfix(Player __instance, byte[] data, bool forceSync)
			{
				//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)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: 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_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				if (!Plugin.EnableBackpackAlert.Value)
				{
					return;
				}
				try
				{
					if ((Object)(object)__instance.character == (Object)(object)Character.localCharacter)
					{
						return;
					}
					string text = ((Object)__instance).name.Replace("Player: ", "");
					if (data != null && data.Length != 0)
					{
						InventorySyncData fromManagedArray = IBinarySerializable.GetFromManagedArray<InventorySyncData>(data);
						if (fromManagedArray.tempSlot.ItemID != ushort.MaxValue && fromManagedArray.tempSlot.Data != null)
						{
							string itemName = GetItemName(fromManagedArray.tempSlot.ItemID);
							if (Plugin.RegisterItem.ContainsKey(fromManagedArray.tempSlot.Data.guid))
							{
								Plugin.Notification(Plugin.AddColor(text, "FF6B6B") + " has taken the " + Plugin.AddColor(itemName, "00FFFF") + " from your backpack!", "FFFFFF", sound: true);
							}
						}
						for (int i = 0; i < fromManagedArray.slots.Length; i++)
						{
							SlotData val = fromManagedArray.slots[i];
							if (val.ItemID != ushort.MaxValue)
							{
								string itemName2 = GetItemName(val.ItemID);
								if (val.Data != null && Plugin.RegisterItem.ContainsKey(val.Data.guid))
								{
									Plugin.Notification(Plugin.AddColor(text, "FF6B6B") + " has taken the " + Plugin.AddColor(itemName2, "00FFFF") + " from your backpack!", "FFFFFF", sound: true);
								}
							}
						}
					}
					else
					{
						Plugin.Log.LogMessage((object)"Data is null or empty");
					}
				}
				catch (Exception arg)
				{
					Plugin.Log.LogError((object)$"Error in SyncInventoryRPC_Patch: {arg}");
				}
			}
		}

		[HarmonyPatch(typeof(Item), "Interact")]
		public class InteractPatch
		{
			[HarmonyPostfix]
			public static void Postfix(Item __instance, Character interactor)
			{
				if ((Object)(object)__instance != (Object)null && __instance.data != null)
				{
					_ = __instance.data.guid;
					Guid guid = __instance.data.guid;
					if (Plugin.RegisterItem.ContainsKey(guid))
					{
						int num = Plugin.RegisterItem[guid];
						Plugin.RegisterItem.Remove(guid);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Item), "PutInBackpackRPC")]
		public class PutInBackpackRPCPatch
		{
			[HarmonyPostfix]
			public static void Postfix(Item __instance, byte slotID, ref BackpackReference backpackReference)
			{
				ItemInstanceData itemInstanceData = ((BackpackReference)(ref backpackReference)).GetItemInstanceData();
				Guid guid = itemInstanceData.guid;
				Guid? registerBackpack = Plugin.RegisterBackpack;
				if (!(guid == registerBackpack))
				{
					return;
				}
				Plugin.RegisterItem.Clear();
				BackpackData data = ((BackpackReference)(ref backpackReference)).GetData();
				for (int i = 0; i < data.itemSlots.Length; i++)
				{
					if (!data.itemSlots[i].IsEmpty())
					{
						Guid guid2 = data.itemSlots[i].data.guid;
						if (!Plugin.RegisterItem.ContainsKey(guid2))
						{
							Plugin.RegisterItem.Add(guid2, i);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(BackpackWheel), "Choose")]
		public class ChoosePatch
		{
			[HarmonyPostfix]
			public static void Postfix(BackpackWheel __instance)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				if (!__instance.chosenSlice.IsSome || !__instance.chosenSlice.Value.isBackpackWear)
				{
					return;
				}
				SliceData value = __instance.chosenSlice.Value;
				Backpack val = default(Backpack);
				if (!((BackpackReference)(ref value.backpackReference)).TryGetBackpackItem(ref val))
				{
					return;
				}
				Plugin.Log.LogMessage((object)$"                    Picking up backpack : {((Item)val).data.guid}");
				Plugin.RegisterBackpack = ((Item)val).data.guid;
				Plugin.RegisterItem.Clear();
				EmptySlotPatch.CancelBackpackRemoval(((Item)val).data.guid);
				BackpackData data = ((Item)val).GetData<BackpackData>((DataEntryKey)7);
				for (int i = 0; i < data.itemSlots.Length; i++)
				{
					if (!data.itemSlots[i].IsEmpty())
					{
						Guid guid = data.itemSlots[i].data.guid;
						if (!Plugin.RegisterItem.ContainsKey(guid))
						{
							Plugin.RegisterItem.Add(guid, i);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(BackpackWheel), "TryStash")]
		public class TryStashPatch
		{
			[HarmonyPrefix]
			public static void Prefix(BackpackWheel __instance, byte backpackSlotID)
			{
				Backpack component = ((Component)__instance.backpack.view).GetComponent<Backpack>();
				Guid guid;
				Guid? registerBackpack;
				if ((Object)(object)component != (Object)null)
				{
					if (!Plugin.RegisterBackpack.HasValue)
					{
						return;
					}
					guid = ((Item)component).data.guid;
					registerBackpack = Plugin.RegisterBackpack;
					if (guid == registerBackpack)
					{
						Item currentItem = Character.localCharacter.data.currentItem;
						Guid guid2 = currentItem.data.guid;
						if (!Plugin.RegisterItem.ContainsKey(guid2))
						{
							Plugin.RegisterItem.Add(guid2, backpackSlotID);
						}
					}
					return;
				}
				guid = ((ItemSlot)((Component)__instance.backpack.view).GetComponent<CharacterBackpackHandler>().character.player.backpackSlot).data.guid;
				registerBackpack = Plugin.RegisterBackpack;
				if (guid == registerBackpack)
				{
					Item currentItem2 = Character.localCharacter.data.currentItem;
					Guid guid3 = currentItem2.data.guid;
					if (!Plugin.RegisterItem.ContainsKey(guid3))
					{
						Plugin.RegisterItem.Add(guid3, backpackSlotID);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "EmptySlot")]
		public class EmptySlotPatch
		{
			[CompilerGenerated]
			private sealed class <DelayedBackpackRemoval>d__5 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public Guid backpackGuid;

				private float <startTime>5__2;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<startTime>5__2 = Time.time;
						<>2__current = (object)new WaitForSeconds(Plugin.unregisterTime);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Plugin.Log.LogMessage((object)$"Time passed (actual: {Time.time - <startTime>5__2:F2}s). Unregistering backpack: {backpackGuid}");
						if (Plugin.RegisterBackpack == backpackGuid)
						{
							Plugin.RegisterBackpack = null;
							Plugin.RegisterItem.Clear();
							Plugin.Log.LogMessage((object)"Backpack successfully unregistered");
						}
						else
						{
							Plugin.Log.LogMessage((object)"Backpack was already changed, skipping unregister");
						}
						pendingRemovals.Remove(backpackGuid);
						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 Dictionary<Guid, Coroutine> pendingRemovals = new Dictionary<Guid, Coroutine>();

			private static MonoBehaviour coroutineRunner;

			[HarmonyPostfix]
			public static void Postfix(Player __instance, ref Optionable<byte> slot)
			{
				if ((Object)(object)coroutineRunner == (Object)null)
				{
					coroutineRunner = (MonoBehaviour)(object)__instance;
				}
				if (slot.IsNone)
				{
					return;
				}
				byte value = slot.Value;
				ItemSlot itemSlot = __instance.GetItemSlot(value);
				if (itemSlot != null && Plugin.RegisterBackpack.HasValue)
				{
					Guid guid = itemSlot.data.guid;
					Guid? registerBackpack = Plugin.RegisterBackpack;
					if (registerBackpack.HasValue && guid == registerBackpack.GetValueOrDefault() && Plugin.RegisterBackpack.HasValue)
					{
						Plugin.Log.LogMessage((object)$"Backpack dropped: {Plugin.RegisterBackpack}. Will unregister in {Plugin.unregisterTime} seconds.");
						Guid value2 = Plugin.RegisterBackpack.Value;
						CancelPendingRemoval(value2);
						Coroutine value3 = coroutineRunner.StartCoroutine(DelayedBackpackRemoval(value2));
						pendingRemovals[value2] = value3;
					}
				}
			}

			public static void CancelBackpackRemoval(Guid backpackGuid)
			{
				if (CancelPendingRemoval(backpackGuid))
				{
					Plugin.Log.LogMessage((object)$"Cancelled backpack removal for: {backpackGuid}");
				}
			}

			private static bool CancelPendingRemoval(Guid backpackGuid)
			{
				if (pendingRemovals.ContainsKey(backpackGuid))
				{
					if ((Object)(object)coroutineRunner != (Object)null)
					{
						coroutineRunner.StopCoroutine(pendingRemovals[backpackGuid]);
					}
					pendingRemovals.Remove(backpackGuid);
					return true;
				}
				return false;
			}

			[IteratorStateMachine(typeof(<DelayedBackpackRemoval>d__5))]
			private static IEnumerator DelayedBackpackRemoval(Guid backpackGuid)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <DelayedBackpackRemoval>d__5(0)
				{
					backpackGuid = backpackGuid
				};
			}
		}

		[HarmonyPatch(typeof(Player), "AddItem")]
		public class AddItemPatch
		{
			[HarmonyPostfix]
			public static void Postfix(Player __instance, ushort itemID, ItemInstanceData instanceData, bool __result, ref ItemSlot slot)
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: 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_015b: 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_0077: 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_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				if (!Plugin.EnableBackpackAlert.Value || !PhotonNetwork.IsMasterClient || (Object)(object)__instance.character == (Object)(object)Character.localCharacter)
				{
					return;
				}
				string text = ((Object)__instance).name.Replace("Player: ", "");
				InventorySyncData val = default(InventorySyncData);
				((InventorySyncData)(ref val))..ctor(__instance.itemSlots, __instance.backpackSlot, __instance.tempFullSlot);
				if (val.tempSlot.ItemID != ushort.MaxValue && val.tempSlot.Data != null)
				{
					string itemName = GetItemName(val.tempSlot.ItemID);
					if (Plugin.RegisterItem.ContainsKey(val.tempSlot.Data.guid))
					{
						Plugin.Notification(Plugin.AddColor(text, "FF6B6B") + " has taken the " + Plugin.AddColor(itemName, "00FFFF") + " from your backpack!", "FFFFFF", sound: true);
					}
				}
				for (int i = 0; i < val.slots.Length; i++)
				{
					SlotData val2 = val.slots[i];
					if (val2.ItemID != ushort.MaxValue)
					{
						string itemName2 = GetItemName(val2.ItemID);
						if (val2.Data != null && Plugin.RegisterItem.ContainsKey(val2.Data.guid))
						{
							Plugin.Notification(Plugin.AddColor(text, "FF6B6B") + " has taken the " + Plugin.AddColor(itemName2, "00FFFF") + " from your backpack!", "FFFFFF", sound: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(Action_RaycastDart), "RPC_DartImpact")]
		public class Patch_DartImpact
		{
			private static int lastFrameLogged = -1;

			private static Vector3 lastPosition = Vector3.zero;

			[HarmonyPrefix]
			private static void Prefix(Action_RaycastDart __instance, int characterID, Vector3 origin, Vector3 endpoint, PhotonMessageInfo info)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				if (!Plugin.EnableBlowgunAlert.Value || info.Sender.ActorNumber == PhotonNetwork.LocalPlayer.ActorNumber || (lastFrameLogged == Time.frameCount && Vector3.Distance(lastPosition, endpoint) < 0.1f))
				{
					return;
				}
				lastFrameLogged = Time.frameCount;
				lastPosition = endpoint;
				Player sender = info.Sender;
				string text = ((sender != null) ? sender.NickName : "Unknown");
				string text2 = "Miss";
				bool flag = characterID != -1;
				if (flag)
				{
					PhotonView photonView = PhotonNetwork.GetPhotonView(characterID);
					Character val = ((photonView != null) ? ((Component)photonView).gameObject.GetComponent<Character>() : null);
					text2 = (((Object)(object)val != (Object)null) ? val.characterName : "Unknown");
					if ((Object)(object)val != (Object)null && (Object)(object)val == (Object)(object)Character.localCharacter)
					{
						Plugin.Notification(string.Format("{0} Shooter: {1} | Hit: {2} | Position: {3}", Plugin.AddColor("[Dart Shot]", "FF0000"), Plugin.AddColor(text, "FF6B6B"), Plugin.AddColor(text2, "00FFFF"), endpoint), "FFFF00", sound: true);
					}
					else
					{
						Plugin.Notification(string.Format("[Dart Shot] Shooter: {0} | Hit: {1} | Position: {2}", Plugin.AddColor(text, "FF6B6B"), Plugin.AddColor(text2, "00FFFF"), endpoint), "FFFF00");
					}
				}
				else
				{
					Plugin.Notification(string.Format("[Dart Shot] Shooter: {0} | Hit: {1} | Position: {2}", Plugin.AddColor(text, "FF6B6B"), Plugin.AddColor(text2, "00FFFF"), endpoint), "FFFF00");
				}
				Character shooter = default(Character);
				if (!flag && (Object)(object)__instance != (Object)null && PlayerHandler.TryGetCharacter(info.Sender.ActorNumber, ref shooter))
				{
					CheckForNearMisses(endpoint, shooter);
				}
			}

			private static void CheckForNearMisses(Vector3 impactPoint, Character shooter)
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				Player[] playerList = PhotonNetwork.PlayerList;
				HashSet<Character> hashSet = new HashSet<Character>();
				Player[] array = playerList;
				Character val2 = default(Character);
				foreach (Player val in array)
				{
					int actorNumber = val.ActorNumber;
					if (!PlayerHandler.TryGetCharacter(actorNumber, ref val2) || !((Object)(object)val2 != (Object)(object)shooter))
					{
						continue;
					}
					float num = Vector3.Distance(impactPoint, val2.Center);
					if (num < 3f)
					{
						hashSet.Add(val2);
						string text = $"{num:F2}m";
						if ((Object)(object)val2 == (Object)(object)Character.localCharacter)
						{
							Plugin.Notification(Plugin.AddColor("[Near Miss]", "FF0000") + " Character: " + Plugin.AddColor(val2.characterName, "FF6B6B") + " | Distance: " + Plugin.AddColor(text, "00FFFF"), "FFFF00", sound: true);
						}
						else
						{
							Plugin.Notification("[Near Miss] Character: " + Plugin.AddColor(val2.characterName, "00FFFF") + " | Distance: " + Plugin.AddColor(text, "00FFFF"), "FFFF00");
						}
					}
				}
			}
		}

		public static string GetItemName(ushort itemID)
		{
			Item val = default(Item);
			if (ItemDatabase.TryGetItem(itemID, ref val))
			{
				return ((Object)val).name ?? "Unknown";
			}
			return "Not Found";
		}
	}
	[BepInPlugin("my.pahsiv.MyBackpackAlert", "MyBackpackAlert", "0.1.2")]
	public class Plugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <CheckBackpack>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					try
					{
						if ((Object)(object)Character.localCharacter == (Object)null)
						{
							Log.LogMessage((object)"Error: Character.localCharacter is null in CheckBackpack()");
							return false;
						}
						if ((Object)(object)Character.localCharacter.player == (Object)null)
						{
							Log.LogMessage((object)"Error: Character.localCharacter.player is null in CheckBackpack()");
							return false;
						}
						if (Character.localCharacter.player.backpackSlot == null)
						{
							Log.LogMessage((object)"Error: backpackSlot is null in CheckBackpack()");
							return false;
						}
						if (Character.localCharacter.player.backpackSlot.hasBackpack)
						{
							RegisterBackpack = ((ItemSlot)Character.localCharacter.player.backpackSlot).data.guid;
							Log.LogMessage((object)$"Picking up backpack: {RegisterBackpack}");
							BackpackReference fromEquippedBackpack = BackpackReference.GetFromEquippedBackpack(Character.localCharacter);
							if ((Object)(object)fromEquippedBackpack.view == (Object)null)
							{
								Log.LogMessage((object)"Error: BackpackReference.view is null in CheckBackpack()");
								return false;
							}
							BackpackData data = ((BackpackReference)(ref fromEquippedBackpack)).GetData();
							if (data == null)
							{
								Log.LogMessage((object)"Error: BackpackData is null in CheckBackpack()");
								return false;
							}
							if (data.itemSlots == null)
							{
								Log.LogMessage((object)"Error: itemSlots array is null in CheckBackpack()");
								return false;
							}
							for (int i = 0; i < data.itemSlots.Length; i++)
							{
								if (!data.itemSlots[i].IsEmpty())
								{
									Guid guid = data.itemSlots[i].data.guid;
									if (!RegisterItem.ContainsKey(guid))
									{
										RegisterItem.Add(guid, i);
									}
								}
							}
						}
					}
					catch (Exception ex)
					{
						Log.LogMessage((object)("Exception in CheckBackpack(): " + ex.Message + "\n" + ex.StackTrace));
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <CheckBackpackRoutine>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Expected O, but got Unknown
				int num = <>1__state;
				Plugin plugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					plugin.PerformBackpackCheck();
					break;
				case 2:
					<>1__state = -1;
					if (!RegisterBackpack.HasValue)
					{
						plugin.PerformBackpackCheck();
					}
					break;
				}
				<>2__current = (object)new WaitForSeconds(30f);
				<>1__state = 2;
				return true;
			}

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

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

		public static ManualLogSource Log = null;

		public static Guid? RegisterBackpack;

		public static Dictionary<Guid, int> RegisterItem = new Dictionary<Guid, int>();

		public static float unregisterTime = 30f;

		private Coroutine backpackCheckCoroutine;

		public static ConfigEntry<bool> EnableBackpackAlert;

		public static ConfigEntry<bool> EnableBlowgunAlert;

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

		internal static Plugin Instance { get; private set; } = null;


		public static string Name => "MyBackpackAlert";

		public static string Version => "0.1.2";

		public Plugin()
		{
			Log = ((BaseUnityPlugin)this).Logger;
		}

		private void Awake()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Instance = this;
			Harmony val = new Harmony("my.pahsiv.MyBackpackAlert");
			val.PatchAll();
			BindConfig();
			SceneManager.sceneLoaded += OnSceneLoaded;
			Log.LogMessage((object)("           Plugin " + Name + " is loaded!"));
		}

		private void BindConfig()
		{
			EnableBackpackAlert = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enable Backpack Alert", true, "Enable or disable alerts for Backpack.");
			EnableBlowgunAlert = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enable Blowgun Alert", true, "Enable or disable alerts for Blowgun.");
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (((Scene)(ref scene)).name == "Airport")
			{
				StopBackpackCheck();
				RegisterBackpack = null;
				RegisterItem.Clear();
			}
			else if (((Scene)(ref scene)).name.Contains("Level_"))
			{
				StartBackpackCheck();
			}
			else if (((Scene)(ref scene)).name.Contains("Title"))
			{
				StopBackpackCheck();
				RegisterBackpack = null;
				RegisterItem.Clear();
			}
		}

		public void StartBackpackCheck()
		{
			Log.LogMessage((object)"Backpack check coroutine started.");
			backpackCheckCoroutine = ((MonoBehaviour)this).StartCoroutine(CheckBackpackRoutine());
		}

		public void StopBackpackCheck()
		{
			if (backpackCheckCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(backpackCheckCoroutine);
				backpackCheckCoroutine = null;
				Log.LogMessage((object)"Backpack check coroutine stopped.");
			}
		}

		[IteratorStateMachine(typeof(<CheckBackpackRoutine>d__17))]
		private IEnumerator CheckBackpackRoutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CheckBackpackRoutine>d__17(0)
			{
				<>4__this = this
			};
		}

		private void PerformBackpackCheck()
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)Character.localCharacter == (Object)null)
				{
					Log.LogMessage((object)"Error: Character.localCharacter is null in PerformBackpackCheck()");
				}
				else if ((Object)(object)Character.localCharacter.player == (Object)null)
				{
					Log.LogMessage((object)"Error: Character.localCharacter.player is null in PerformBackpackCheck()");
				}
				else if (Character.localCharacter.player.backpackSlot == null)
				{
					Log.LogMessage((object)"Error: backpackSlot is null in PerformBackpackCheck()");
				}
				else
				{
					if (!Character.localCharacter.player.backpackSlot.hasBackpack)
					{
						return;
					}
					RegisterBackpack = ((ItemSlot)Character.localCharacter.player.backpackSlot).data.guid;
					Log.LogMessage((object)$"Picking up backpack: {RegisterBackpack}");
					BackpackReference fromEquippedBackpack = BackpackReference.GetFromEquippedBackpack(Character.localCharacter);
					if ((Object)(object)fromEquippedBackpack.view == (Object)null)
					{
						Log.LogMessage((object)"Error: BackpackReference.view is null in PerformBackpackCheck()");
						return;
					}
					BackpackData data = ((BackpackReference)(ref fromEquippedBackpack)).GetData();
					if (data == null)
					{
						Log.LogMessage((object)"Error: BackpackData is null in PerformBackpackCheck()");
						return;
					}
					if (data.itemSlots == null)
					{
						Log.LogMessage((object)"Error: itemSlots array is null in PerformBackpackCheck()");
						return;
					}
					for (int i = 0; i < data.itemSlots.Length; i++)
					{
						if (!data.itemSlots[i].IsEmpty())
						{
							Guid guid = data.itemSlots[i].data.guid;
							if (!RegisterItem.ContainsKey(guid))
							{
								RegisterItem.Add(guid, i);
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogMessage((object)("Exception in PerformBackpackCheck(): " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		[IteratorStateMachine(typeof(<CheckBackpack>d__19))]
		public static IEnumerator CheckBackpack()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CheckBackpack>d__19(0);
		}

		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
			{
				Log.LogWarning((object)"AddMessage method not found.");
			}
		}

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

		public static string GetItemName(ushort itemID)
		{
			Item val = default(Item);
			if (ItemDatabase.TryGetItem(itemID, ref val))
			{
				return ((Object)val).name ?? "Unknown";
			}
			return "Not Found";
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}