using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Photon.Pun;
using UnityEngine;
using UnityEngine.SceneManagement;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Pocket Conch")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Pocket Conch")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a4410986-24cc-4512-83f4-313a05cabc62")]
[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 PocketConch;

[BepInPlugin("tony4twentys.Pocket_Conch", "Pocket Conch", "1.0.6")]
public class Plugin : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <NoDropOnClimb_Transpiler>d__34 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private CodeInstruction <>2__current;

		private int <>l__initialThreadId;

		private IEnumerable<CodeInstruction> instructions;

		public IEnumerable<CodeInstruction> <>3__instructions;

		private List<CodeInstruction> <list>5__1;

		private MethodInfo <equip>5__2;

		private FieldInfo <chField>5__3;

		private MethodInfo <helper>5__4;

		private int <i>5__5;

		private CodeInstruction <inst>5__6;

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

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

		[DebuggerHidden]
		public <NoDropOnClimb_Transpiler>d__34(int <>1__state)
		{
			this.<>1__state = <>1__state;
			<>l__initialThreadId = Environment.CurrentManagedThreadId;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<list>5__1 = null;
			<equip>5__2 = null;
			<chField>5__3 = null;
			<helper>5__4 = null;
			<inst>5__6 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<list>5__1 = new List<CodeInstruction>(instructions);
				<equip>5__2 = AccessTools.Method(typeof(CharacterItems), "EquipSlot", new Type[1] { typeof(Optionable<byte>) }, (Type[])null);
				<chField>5__3 = AccessTools.Field(typeof(CharacterClimbing), "character");
				<helper>5__4 = AccessTools.Method(typeof(Plugin), "ClearHandsForClimb", (Type[])null, (Type[])null);
				<i>5__5 = 0;
				break;
			case 1:
				<>1__state = -1;
				<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>2__current = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>2__current = new CodeInstruction(OpCodes.Ldfld, (object)<chField>5__3);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>2__current = new CodeInstruction(OpCodes.Call, (object)<helper>5__4);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				goto IL_01fb;
			case 6:
				{
					<>1__state = -1;
					<inst>5__6 = null;
					goto IL_01fb;
				}
				IL_01fb:
				<i>5__5++;
				break;
			}
			if (<i>5__5 < <list>5__1.Count)
			{
				<inst>5__6 = <list>5__1[<i>5__5];
				if (<inst>5__6.opcode == OpCodes.Callvirt && object.Equals(<inst>5__6.operand, <equip>5__2))
				{
					<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
					<>1__state = 1;
					return true;
				}
				<>2__current = <inst>5__6;
				<>1__state = 6;
				return true;
			}
			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();
		}

		[DebuggerHidden]
		IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
		{
			<NoDropOnClimb_Transpiler>d__34 <NoDropOnClimb_Transpiler>d__;
			if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
			{
				<>1__state = 0;
				<NoDropOnClimb_Transpiler>d__ = this;
			}
			else
			{
				<NoDropOnClimb_Transpiler>d__ = new <NoDropOnClimb_Transpiler>d__34(0);
			}
			<NoDropOnClimb_Transpiler>d__.instructions = <>3__instructions;
			return <NoDropOnClimb_Transpiler>d__;
		}

		[DebuggerHidden]
		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
		}
	}

	public const string Id = "tony4twentys.Pocket_Conch";

	public const string Name = "Pocket Conch";

	public const string Version = "1.0.6";

	private static readonly FieldRef<CharacterItems, Character> _characterRef = AccessTools.FieldRefAccess<CharacterItems, Character>("character");

	private static readonly FieldRef<CharacterClimbing, Character> _climbCharacterRef = AccessTools.FieldRefAccess<CharacterClimbing, Character>("character");

	private static readonly FieldRef<CharacterVineClimbing, Character> _vineCharacterRef = AccessTools.FieldRefAccess<CharacterVineClimbing, Character>("character");

	private static readonly FieldRef<CharacterRopeHandling, Character> _ropeCharacterRef = AccessTools.FieldRefAccess<CharacterRopeHandling, Character>("character");

	private const ushort ConchItemID = 69;

	private const string ConchItemName = "Shell Big";

	private const byte TempSlotId = 250;

	private ConfigEntry<KeyCode> _pocketKey;

	private ConfigEntry<KeyCode> _pocketModifier;

	private const float GUARD_WINDOW = 0.3f;

	private const float GUARD_BLOCK = 1.5f;

	private static Plugin _instance;

	private float _lastUnselectSwitchTime;

	private float _suppressSpawnUntil;

	private float _toggleBlockUntil;

	private float _lastToggleTime1;

	private float _lastToggleTime2;

	private int _cooldownTriggers;

	private void Awake()
	{
		_instance = this;
		((BaseUnityPlugin)this).Logger.LogInfo((object)"[Pocket Conch] Awake...");
		_pocketKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Control", "PocketKey", (KeyCode)99, "Key to spawn/equip or destroy the conch when held with the modifier.");
		_pocketModifier = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Control", "PocketModifier", (KeyCode)308, "Modifier key that must be held with PocketKey.");
		SceneManager.activeSceneChanged += OnSceneChanged;
		Harmony.CreateAndPatchAll(typeof(Plugin), (string)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"[Pocket Conch] Ready.");
	}

	private static bool IsConch(Item item)
	{
		return (Object)(object)item != (Object)null && item.itemID == 69;
	}

	private static bool IsHoldingConch(Character ch)
	{
		return (Object)(object)ch != (Object)null && IsConch(ch.data.currentItem);
	}

	private static void DestroyHeldItem(Character ch)
	{
		((MonoBehaviourPun)ch.refs.items).photonView.RPC("DestroyHeldItemRpc", PhotonNetwork.LocalPlayer, Array.Empty<object>());
	}

	private static bool TryDestroyHeldConch(Character ch)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		if (!IsHoldingConch(ch))
		{
			return false;
		}
		DestroyHeldItem(ch);
		try
		{
			Optionable<byte> currentSelectedSlot = ch.refs.items.currentSelectedSlot;
			if (currentSelectedSlot.IsSome)
			{
				byte value = currentSelectedSlot.Value;
				ItemSlot[] array = ch.player?.itemSlots;
				if (array != null && value < array.Length)
				{
					ItemSlot val = array[value];
					if (val != null && IsConch(val.prefab))
					{
						ch.player.EmptySlot(currentSelectedSlot);
					}
				}
			}
		}
		catch
		{
		}
		try
		{
			Player player = ch.player;
			if (player != null)
			{
				player.EmptySlot(Optionable<byte>.Some((byte)250));
			}
		}
		catch
		{
		}
		try
		{
			ch.refs.items.EquipSlot(Optionable<byte>.None);
		}
		catch
		{
		}
		return true;
	}

	private static int FindConchIndexPrimary(Character ch)
	{
		if ((Object)(object)ch == (Object)null || (Object)(object)ch.player == (Object)null || ch.player.itemSlots == null)
		{
			return -1;
		}
		ItemSlot[] itemSlots = ch.player.itemSlots;
		int num = Mathf.Min(itemSlots.Length, 3);
		for (int i = 0; i < num; i++)
		{
			ItemSlot val = itemSlots[i];
			if (val != null && !val.IsEmpty() && IsConch(val.prefab))
			{
				return i;
			}
		}
		return -1;
	}

	private static bool RemoveConchFromPrimary(Character ch)
	{
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: 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)
		if ((Object)(object)ch == (Object)null)
		{
			return false;
		}
		int num = FindConchIndexPrimary(ch);
		if (num < 0)
		{
			return false;
		}
		try
		{
			ch.refs.items.EquipSlot(Optionable<byte>.None);
		}
		catch
		{
		}
		try
		{
			Player player = ch.player;
			if (player != null)
			{
				player.EmptySlot(Optionable<byte>.Some((byte)250));
			}
		}
		catch
		{
		}
		ch.refs.items.EquipSlot(Optionable<byte>.Some((byte)num));
		if (TryDestroyHeldConch(ch))
		{
			return true;
		}
		return false;
	}

	private static bool TryEquipConch(Character ch)
	{
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		if (IsHoldingConch(ch))
		{
			return true;
		}
		if (!ch.player.tempFullSlot.IsEmpty())
		{
			return true;
		}
		ItemSlot[] array = ch.player.itemSlots ?? Array.Empty<ItemSlot>();
		for (byte b = 0; b < array.Length; b++)
		{
			ItemSlot val = array[b];
			if (val != null && IsConch(val.prefab))
			{
				ch.refs.items.EquipSlot(Optionable<byte>.Some(b));
				return true;
			}
		}
		return false;
	}

	private static void SpawnConch(Character ch)
	{
		((MonoBehaviourPun)ch.refs.items).photonView.RPC("RPC_SpawnItemInHandMaster", (RpcTarget)2, new object[1] { "Shell Big" });
	}

	private void Update()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		if (!Input.GetKey(_pocketModifier.Value) || !Input.GetKeyDown(_pocketKey.Value))
		{
			return;
		}
		Character localCharacter = Character.localCharacter;
		if ((Object)(object)localCharacter == (Object)null)
		{
			return;
		}
		float unscaledTime = Time.unscaledTime;
		if (unscaledTime < _toggleBlockUntil)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[Pocket Conch] Toggle is on cooldown.");
		}
		else if (_lastToggleTime2 > 0f && unscaledTime - _lastToggleTime2 <= 1f)
		{
			_cooldownTriggers++;
			float num = 5f * (float)_cooldownTriggers;
			_toggleBlockUntil = unscaledTime + num;
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Pocket Conch] Toggle spam detected. Cooldown {num:0.0}s (x{_cooldownTriggers}).");
		}
		else if (TryDestroyHeldConch(localCharacter))
		{
			_lastToggleTime2 = _lastToggleTime1;
			_lastToggleTime1 = unscaledTime;
		}
		else if (RemoveConchFromPrimary(localCharacter))
		{
			_lastToggleTime2 = _lastToggleTime1;
			_lastToggleTime1 = unscaledTime;
		}
		else if ((Object)(object)localCharacter.data != (Object)null && localCharacter.data.isGrounded && !localCharacter.data.isClimbingAnything)
		{
			unscaledTime = Time.unscaledTime;
			if (unscaledTime - _lastUnselectSwitchTime <= 0.3f && unscaledTime >= _suppressSpawnUntil)
			{
				_suppressSpawnUntil = unscaledTime + 1.5f;
			}
			if (!(unscaledTime < _suppressSpawnUntil))
			{
				SpawnConch(localCharacter);
				_lastToggleTime2 = _lastToggleTime1;
				_lastToggleTime1 = unscaledTime;
			}
		}
		else
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[Pocket Conch] Cannot spawn while climbing or when not grounded.");
		}
	}

	private void OnDestroy()
	{
		SceneManager.activeSceneChanged -= OnSceneChanged;
	}

	private void OnSceneChanged(Scene oldScene, Scene newScene)
	{
		_cooldownTriggers = 0;
		_lastToggleTime1 = 0f;
		_lastToggleTime2 = 0f;
		_toggleBlockUntil = 0f;
		((BaseUnityPlugin)this).Logger.LogInfo((object)"[Pocket Conch] Scene changed — toggle cooldown reset.");
	}

	private static void ClearHandsForClimb(Character ch)
	{
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)ch == (Object)null || (Object)(object)ch.data == (Object)null)
		{
			return;
		}
		if (IsHoldingConch(ch) && IsInventoryFull(ch))
		{
			((MonoBehaviourPun)ch.refs.items).photonView.RPC("DestroyHeldItemRpc", PhotonNetwork.LocalPlayer, Array.Empty<object>());
			if ((Object)(object)ch.player != (Object)null)
			{
				ch.player.EmptySlot(Optionable<byte>.Some((byte)250));
			}
		}
		ch.refs.items.EquipSlot(Optionable<byte>.None);
	}

	[IteratorStateMachine(typeof(<NoDropOnClimb_Transpiler>d__34))]
	[HarmonyPatch(typeof(CharacterClimbing), "TryToStartWallClimb")]
	[HarmonyTranspiler]
	private static IEnumerable<CodeInstruction> NoDropOnClimb_Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <NoDropOnClimb_Transpiler>d__34(-2)
		{
			<>3__instructions = instructions
		};
	}

	[HarmonyPatch(typeof(CharacterVineClimbing), "GrabVineRpc")]
	[HarmonyPrefix]
	private static void Pre_GrabVine(CharacterVineClimbing __instance)
	{
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		Character val = _vineCharacterRef.Invoke(__instance);
		if ((Object)(object)val == (Object)null || !val.IsLocal || (Object)(object)val.data == (Object)null || !IsHoldingConch(val) || !IsInventoryFull(val))
		{
			return;
		}
		((MonoBehaviourPun)val.refs.items).photonView.RPC("DestroyHeldItemRpc", PhotonNetwork.LocalPlayer, Array.Empty<object>());
		try
		{
			val.refs.items.EquipSlot(Optionable<byte>.None);
		}
		catch
		{
		}
	}

	[HarmonyPatch(typeof(CharacterRopeHandling), "GrabRopeRpc")]
	[HarmonyPrefix]
	private static void Pre_GrabRope(CharacterRopeHandling __instance)
	{
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		Character val = _ropeCharacterRef.Invoke(__instance);
		if ((Object)(object)val == (Object)null || !val.IsLocal || (Object)(object)val.data == (Object)null || !IsHoldingConch(val) || !IsInventoryFull(val))
		{
			return;
		}
		((MonoBehaviourPun)val.refs.items).photonView.RPC("DestroyHeldItemRpc", PhotonNetwork.LocalPlayer, Array.Empty<object>());
		try
		{
			val.refs.items.EquipSlot(Optionable<byte>.None);
		}
		catch
		{
		}
	}

	[HarmonyPatch(typeof(CharacterItems), "EquipSlot")]
	[HarmonyPrefix]
	private static void Pre_EquipSlot(CharacterItems __instance, Optionable<byte> slotID)
	{
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Character val = _characterRef.Invoke(__instance);
			if (!((Object)(object)val == (Object)null) && val.IsLocal && !((Object)(object)val.data == (Object)null) && !slotID.IsSome && (Object)(object)val.data.currentItem != (Object)null && IsConch(val.data.currentItem) && IsInventoryFull(val))
			{
				__instance.DestroyHeldItemRpc();
				Player player = val.player;
				if ((Object)(object)player != (Object)null)
				{
					player.EmptySlot(Optionable<byte>.Some((byte)250));
				}
			}
		}
		catch
		{
		}
	}

	[HarmonyPatch(typeof(CharacterItems), "DropAllItems")]
	[HarmonyPrefix]
	private static bool DropAllExceptConch(CharacterItems __instance, bool includeBackpack)
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0215: Unknown result type (might be due to invalid IL or missing references)
		//IL_021a: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
		Character val = _characterRef.Invoke(__instance);
		if ((Object)(object)val == (Object)null)
		{
			return true;
		}
		if ((Object)(object)((MonoBehaviourPun)val).photonView == (Object)null || !((MonoBehaviourPun)val).photonView.IsMine)
		{
			return true;
		}
		FieldInfo fieldInfo = AccessTools.Field(typeof(CharacterItems), "currentSelectedSlot");
		FieldInfo fieldInfo2 = AccessTools.Field(typeof(CharacterItems), "throwChargeLevel");
		Optionable<byte> val2 = (Optionable<byte>)fieldInfo.GetValue(__instance);
		float num = (float)fieldInfo2.GetValue(__instance);
		Transform transform = ((Component)val.refs.hip).transform;
		Vector3 val3 = transform.forward;
		if (Vector3.Dot(val3, Vector3.up) < 0f)
		{
			val3 = -val3;
		}
		Vector3 val4 = transform.position + val3 * 0.6f;
		PhotonView component = ((Component)__instance).GetComponent<PhotonView>();
		if (val2.IsSome && Object.op_Implicit((Object)(object)val.data.currentItem))
		{
			byte value = val2.Value;
			ItemSlot itemSlot = val.player.GetItemSlot(value);
			if (!itemSlot.IsEmpty() && (Object)(object)itemSlot.prefab != (Object)null && IsConch(itemSlot.prefab))
			{
				((MonoBehaviourPun)val.player).photonView.RPC("RPCRemoveItemFromSlot", (RpcTarget)2, new object[1] { value });
			}
			else
			{
				component.RPC("DropItemRpc", (RpcTarget)0, new object[6]
				{
					num,
					value,
					((Component)val.data.currentItem).transform.position,
					Vector3.zero,
					((Component)val.data.currentItem).transform.rotation,
					itemSlot.data
				});
			}
			val4 += Vector3.up * 0.5f;
		}
		for (int num2 = (includeBackpack ? 3 : 2); num2 >= 0; num2--)
		{
			byte b = (byte)num2;
			ItemSlot itemSlot2 = val.player.GetItemSlot(b);
			if (!itemSlot2.IsEmpty() && (Object)(object)itemSlot2.prefab != (Object)null && IsConch(itemSlot2.prefab))
			{
				((MonoBehaviourPun)val.player).photonView.RPC("RPCRemoveItemFromSlot", (RpcTarget)2, new object[1] { b });
			}
			else
			{
				component.RPC("DropItemFromSlotRPC", (RpcTarget)0, new object[2] { b, val4 });
			}
			val4 += Vector3.up * 0.5f;
		}
		return false;
	}

	[HarmonyPatch(typeof(CharacterItems), "DoDropping")]
	[HarmonyPrefix]
	private static bool BlockConchDropping(CharacterItems __instance)
	{
		Character val = _characterRef.Invoke(__instance);
		return (Object)(object)val == (Object)null || !IsHoldingConch(val);
	}

	private static bool IsInventoryFull(Character ch)
	{
		if ((Object)(object)ch == (Object)null)
		{
			return false;
		}
		ItemSlot[] array = (((Object)(object)ch.player != (Object)null) ? ch.player.itemSlots : null);
		if (array == null || array.Length == 0)
		{
			return false;
		}
		foreach (ItemSlot val in array)
		{
			if (val == null || val.IsEmpty())
			{
				return false;
			}
		}
		return true;
	}

	private static bool AreMainSlotsFull(Character ch)
	{
		if ((Object)(object)ch == (Object)null || (Object)(object)ch.player == (Object)null || ch.player.itemSlots == null)
		{
			return false;
		}
		ItemSlot[] itemSlots = ch.player.itemSlots;
		int num = Mathf.Min(itemSlots.Length, 3);
		for (int i = 0; i < num; i++)
		{
			ItemSlot val = itemSlots[i];
			if (val == null || val.IsEmpty())
			{
				return false;
			}
		}
		return num == 3;
	}

	private static bool HasConchInMainSlots(Character ch)
	{
		if ((Object)(object)ch == (Object)null || (Object)(object)ch.player == (Object)null || ch.player.itemSlots == null)
		{
			return false;
		}
		ItemSlot[] itemSlots = ch.player.itemSlots;
		int num = Mathf.Min(itemSlots.Length, 3);
		for (int i = 0; i < num; i++)
		{
			ItemSlot val = itemSlots[i];
			if (val != null && !val.IsEmpty() && IsConch(val.prefab))
			{
				return true;
			}
		}
		return false;
	}

	private static bool InventoryFullOfNonConch(Character ch)
	{
		return AreMainSlotsFull(ch) && !HasConchInMainSlots(ch);
	}

	[HarmonyPatch(typeof(CharacterItems), "DoSwitching")]
	[HarmonyPrefix]
	private static bool BlockConchSwitchWhenFull(CharacterItems __instance)
	{
		Character val = _characterRef.Invoke(__instance);
		if ((Object)(object)val != (Object)null && val.IsLocal)
		{
			try
			{
				CharacterInput input = val.input;
				if ((Object)(object)input != (Object)null && input.unselectSlotWasPressed && (Object)(object)_instance != (Object)null)
				{
					_instance._lastUnselectSwitchTime = Time.unscaledTime;
				}
			}
			catch
			{
			}
		}
		if ((Object)(object)val == (Object)null || !val.IsLocal)
		{
			return true;
		}
		if (!IsHoldingConch(val))
		{
			return true;
		}
		if (!InventoryFullOfNonConch(val))
		{
			return true;
		}
		return false;
	}
}