using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 Coldre
{
	[BepInPlugin("razaotium.coldre", "Coldre", "0.4.1")]
	public class Coldre : BaseUnityPlugin
	{
		public const string GUID = "razaotium.coldre";

		public const string VERSAO = "0.4.1";

		public static ConfigEntry<bool> Ativo;

		public static ConfigEntry<bool> GuardarAoTrocar;

		public static ConfigEntry<bool> FerramentasTambem;

		public static ConfigEntry<int> Limite;

		public static ConfigEntry<bool> DoisToquesTrocam;

		public static ConfigEntry<float> Janela;

		public static ConfigEntry<string> Modo;

		public static ConfigEntry<float> SegurarParaAlternar;

		public const string ModoGuardar = "Guardar";

		public const string ModoTrocar = "Trocar";

		public static ManualLogSource Log;

		private void Awake()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			Ativo = ((BaseUnityPlugin)this).Config.Bind<bool>("1 - Geral", "Ativo", true, "Liga ou desliga o mod.");
			GuardarAoTrocar = ((BaseUnityPlugin)this).Config.Bind<bool>("2 - Costas", "Guardar ao trocar de arma", true, "A arma anterior vai para o corpo ao equipar outra.");
			FerramentasTambem = ((BaseUnityPlugin)this).Config.Bind<bool>("2 - Costas", "Ferramentas também", true, "Martelo, enxada e cultivador também vão para o corpo.");
			Limite = ((BaseUnityPlugin)this).Config.Bind<int>("2 - Costas", "Itens no corpo", 4, new ConfigDescription("Quantos itens ficam à mostra no corpo.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 4), Array.Empty<object>()));
			DoisToquesTrocam = ((BaseUnityPlugin)this).Config.Bind<bool>("3 - Botão de guardar", "Dois toques trocam de arma", true, "Dois toques no botão de guardar passam para a próxima arma do corpo.");
			Janela = ((BaseUnityPlugin)this).Config.Bind<float>("3 - Botão de guardar", "Tempo entre os dois toques", 0.3f, new ConfigDescription("Segundos entre os dois toques.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.15f, 0.6f), Array.Empty<object>()));
			Modo = ((BaseUnityPlugin)this).Config.Bind<string>("3 - Botão de guardar", "Modo do botão", "Guardar", new ConfigDescription("Guardar: um toque guarda e dois passam para a próxima arma. Trocar: um toque passa para a próxima e dois guardam.", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[2] { "Guardar", "Trocar" }), Array.Empty<object>()));
			SegurarParaAlternar = ((BaseUnityPlugin)this).Config.Bind<float>("3 - Botão de guardar", "Segurar para mudar o modo", 1f, new ConfigDescription("Segundos segurando o botão de guardar para alternar o modo. 0 desliga.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			new Harmony("razaotium.coldre").PatchAll(typeof(Coldre).Assembly);
		}
	}
	internal static class Maos
	{
		private static readonly FieldRef<Humanoid, ItemData> direita = AccessTools.FieldRefAccess<Humanoid, ItemData>("m_rightItem");

		private static readonly FieldRef<Humanoid, ItemData> esquerda = AccessTools.FieldRefAccess<Humanoid, ItemData>("m_leftItem");

		private static readonly FieldRef<Humanoid, ItemData> costasDir = AccessTools.FieldRefAccess<Humanoid, ItemData>("m_hiddenRightItem");

		private static readonly FieldRef<Humanoid, ItemData> costasEsq = AccessTools.FieldRefAccess<Humanoid, ItemData>("m_hiddenLeftItem");

		private static readonly FieldRef<Character, ZSyncAnimation> anim = AccessTools.FieldRefAccess<Character, ZSyncAnimation>("m_zanim");

		private static readonly FieldRef<Humanoid, VisEquipment> visual = AccessTools.FieldRefAccess<Humanoid, VisEquipment>("m_visEquipment");

		private static readonly MethodInfo montarVisual = AccessTools.Method(typeof(Humanoid), "SetupVisEquipment", new Type[2]
		{
			typeof(VisEquipment),
			typeof(bool)
		}, (Type[])null);

		public static void AtualizarVisual(Humanoid h)
		{
			montarVisual.Invoke(h, new object[2]
			{
				visual.Invoke(h),
				false
			});
		}

		public static ItemData Direita(Humanoid h)
		{
			return direita.Invoke(h);
		}

		public static ItemData Esquerda(Humanoid h)
		{
			return esquerda.Invoke(h);
		}

		public static ItemData CostasDir(Humanoid h)
		{
			return costasDir.Invoke(h);
		}

		public static ItemData CostasEsq(Humanoid h)
		{
			return costasEsq.Invoke(h);
		}

		public static void PorNasCostas(Humanoid h, ItemData dir, ItemData esq)
		{
			costasDir.Invoke(h) = dir;
			costasEsq.Invoke(h) = esq;
			AtualizarVisual(h);
		}

		public static void AnimacaoDeSacar(Humanoid h)
		{
			ZSyncAnimation val = anim.Invoke((Character)(object)h);
			if ((Object)(object)val != (Object)null)
			{
				val.SetTrigger("equip_hip");
			}
		}

		public static bool EhLocal(Humanoid h)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if ((Object)(object)h != (Object)null && h is Player)
			{
				return (Object)(Player)h == (Object)(object)Player.m_localPlayer;
			}
			return false;
		}

		public static bool EhItemDeMao(ItemData item)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			if (item == null || item.m_shared == null)
			{
				return false;
			}
			ItemType itemType = item.m_shared.m_itemType;
			if ((int)itemType <= 15)
			{
				if (itemType - 3 <= 2 || itemType - 14 <= 1)
				{
					goto IL_0037;
				}
			}
			else if ((int)itemType == 19 || (int)itemType == 22)
			{
				goto IL_0037;
			}
			return false;
			IL_0037:
			return true;
		}

		public static bool PodeIrParaAsCostas(Humanoid h, ItemData item)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			if (!EhItemDeMao(item))
			{
				return false;
			}
			if ((int)item.m_shared.m_itemType == 19 && !Coldre.FerramentasTambem.Value)
			{
				return false;
			}
			if (!h.GetInventory().ContainsItem(item))
			{
				return false;
			}
			if (item == direita.Invoke(h) || item == esquerda.Invoke(h))
			{
				return false;
			}
			return true;
		}
	}
	internal static class Costas
	{
		public const int Melee = 1;

		public const int Duas = 2;

		public const int Arco = 3;

		public const int CinturaDir = 4;

		public const int Atgeir = 5;

		public const int Escudo = 6;

		public const int CinturaEsq = 7;

		public const string ChaveDir = "coldre_p_r";

		public const string ChaveEsq = "coldre_p_l";

		public static readonly string[] ChaveHash = new string[2] { "coldre_x1", "coldre_x2" };

		public static readonly string[] ChaveVariante = new string[2] { "coldre_x1_v", "coldre_x2_v" };

		public static readonly string[] ChaveQualidade = new string[2] { "coldre_x1_q", "coldre_x2_q" };

		public static readonly string[] ChaveLugar = new string[2] { "coldre_x1_p", "coldre_x2_p" };

		private static readonly FieldRef<Character, ZNetView> vista = AccessTools.FieldRefAccess<Character, ZNetView>("m_nview");

		public static readonly ItemData[] Extras = (ItemData[])(object)new ItemData[2];

		private static int[] lugares = new int[4];

		private static Player dono;

		public static List<ItemData> Lista(Humanoid h)
		{
			List<ItemData> list = new List<ItemData>();
			Junta(list, Maos.CostasDir(h));
			Junta(list, Maos.CostasEsq(h));
			Junta(list, Extras[0]);
			Junta(list, Extras[1]);
			return list;
		}

		public static void Junta(List<ItemData> l, ItemData item)
		{
			if (item != null && !l.Contains(item))
			{
				l.Add(item);
			}
		}

		private static ItemType Tipo(ItemData item)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			SharedData shared = item.m_shared;
			if ((int)shared.m_attachOverride == 0)
			{
				return shared.m_itemType;
			}
			return shared.m_attachOverride;
		}

		private static bool EhArco(ItemData i)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			return (int)Tipo(i) == 4;
		}

		private static int Lugar(ItemData i, bool temArco, List<int> usados)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected I4, but got Unknown
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			ItemType val = Tipo(i);
			if ((int)val <= 5)
			{
				if ((int)val != 4)
				{
					if ((int)val != 5)
					{
						goto IL_00ad;
					}
					return Livre(usados, 6);
				}
				return Livre(usados, 3);
			}
			if ((int)val != 14)
			{
				switch (val - 19)
				{
				case 1:
					break;
				case 3:
					goto IL_0079;
				case 0:
					return Livre(usados, 4, 7);
				default:
					goto IL_00ad;
				}
				if (!temArco && !usados.Contains(2))
				{
					return Livre(usados, 5);
				}
				return 0;
			}
			goto IL_0079;
			IL_00ad:
			return Livre(usados, 7, 4);
			IL_0079:
			if (!temArco && !usados.Contains(5))
			{
				return Livre(usados, 2);
			}
			return 0;
		}

		private static int Livre(List<int> usados, params int[] opcoes)
		{
			foreach (int num in opcoes)
			{
				if (!usados.Contains(num))
				{
					return num;
				}
			}
			return 0;
		}

		public static void Distribuir(Humanoid h, List<ItemData> ordem)
		{
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData item in ordem)
			{
				if (Maos.PodeIrParaAsCostas(h, item))
				{
					Junta(list, item);
				}
			}
			bool temArco = false;
			foreach (ItemData item2 in list)
			{
				if (EhArco(item2))
				{
					temArco = true;
				}
			}
			ItemData[] array = (ItemData[])(object)new ItemData[4];
			int[] array2 = new int[4];
			List<int> list2 = new List<int>();
			int num = 0;
			foreach (ItemData item3 in list)
			{
				if (num >= Coldre.Limite.Value)
				{
					break;
				}
				int num2 = Lugar(item3, temArco, list2);
				if (num2 != 0)
				{
					list2.Add(num2);
					array[num] = item3;
					array2[num] = num2;
					num++;
				}
			}
			bool flag = array[0] != Maos.CostasDir(h) || array[1] != Maos.CostasEsq(h) || array[2] != Extras[0] || array[3] != Extras[1];
			for (int i = 0; i < 4; i++)
			{
				if (array2[i] != lugares[i])
				{
					flag = true;
				}
			}
			if (flag)
			{
				Extras[0] = array[2];
				Extras[1] = array[3];
				lugares = array2;
				Maos.PorNasCostas(h, array[0], array[1]);
				Publicar(h);
			}
		}

		public static string Descrever(Humanoid h)
		{
			List<string> list = new List<string>();
			ItemData[] array = (ItemData[])(object)new ItemData[4]
			{
				Maos.CostasDir(h),
				Maos.CostasEsq(h),
				Extras[0],
				Extras[1]
			};
			for (int i = 1; i <= 7; i++)
			{
				for (int j = 0; j < 4; j++)
				{
					if (array[j] != null && lugares[j] == i)
					{
						list.Add((((Object)(object)array[j].m_dropPrefab != (Object)null) ? ((Object)array[j].m_dropPrefab).name : "?") + "@" + i);
					}
				}
			}
			return string.Join(",", list.ToArray());
		}

		private static void Publicar(Humanoid h)
		{
			ZNetView val = vista.Invoke((Character)(object)h);
			if (!((Object)(object)val == (Object)null) && val.IsValid() && val.IsOwner())
			{
				ZDO zDO = val.GetZDO();
				zDO.Set("coldre_p_r", lugares[0]);
				zDO.Set("coldre_p_l", lugares[1]);
				for (int i = 0; i < 2; i++)
				{
					ItemData val2 = Extras[i];
					bool flag = val2 != null && (Object)(object)val2.m_dropPrefab != (Object)null;
					zDO.Set(ChaveHash[i], flag ? StringExtensionMethods.GetStableHashCode(((Object)val2.m_dropPrefab).name) : 0);
					zDO.Set(ChaveVariante[i], flag ? val2.m_variant : 0);
					zDO.Set(ChaveQualidade[i], flag ? val2.m_quality : 0);
					zDO.Set(ChaveLugar[i], flag ? lugares[i + 2] : 0);
				}
			}
		}

		public static void Limpar(Humanoid h)
		{
			Extras[0] = null;
			Extras[1] = null;
			lugares = new int[4];
			if ((Object)(object)h != (Object)null)
			{
				Publicar(h);
			}
		}

		public static void Conferir(Player p)
		{
			if ((Object)(object)dono != (Object)(object)p)
			{
				dono = p;
				Limpar((Humanoid)(object)p);
				return;
			}
			if (!Coldre.Ativo.Value)
			{
				if (Extras[0] != null || Extras[1] != null)
				{
					Limpar((Humanoid)(object)p);
				}
				return;
			}
			bool flag = Maos.CostasDir((Humanoid)(object)p) == null != (lugares[0] == 0) || Maos.CostasEsq((Humanoid)(object)p) == null != (lugares[1] == 0);
			ItemData[] extras = Extras;
			foreach (ItemData val in extras)
			{
				if (val != null && !Maos.PodeIrParaAsCostas((Humanoid)(object)p, val))
				{
					flag = true;
				}
			}
			if (flag)
			{
				Distribuir((Humanoid)(object)p, Lista((Humanoid)(object)p));
			}
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "UpdateVisuals")]
	internal static class DesenhoPatch
	{
		private sealed class Desenho
		{
			public GameObject dir;

			public GameObject esq;

			public int lugarDir;

			public int lugarEsq;

			public readonly GameObject[] obj = (GameObject[])(object)new GameObject[2];

			public readonly int[] hash = new int[2];

			public readonly int[] variante = new int[2];

			public readonly int[] qualidade = new int[2];

			public readonly int[] lugar = new int[2];

			public Transform cinturaEsq;
		}

		private static readonly ConditionalWeakTable<VisEquipment, Desenho> desenhos = new ConditionalWeakTable<VisEquipment, Desenho>();

		private static readonly FieldRef<VisEquipment, ZNetView> vista = AccessTools.FieldRefAccess<VisEquipment, ZNetView>("m_nview");

		private static readonly FieldRef<VisEquipment, GameObject> instDir = AccessTools.FieldRefAccess<VisEquipment, GameObject>("m_rightBackItemInstance");

		private static readonly FieldRef<VisEquipment, GameObject> instEsq = AccessTools.FieldRefAccess<VisEquipment, GameObject>("m_leftBackItemInstance");

		private static readonly MethodInfo anexar = AccessTools.Method(typeof(VisEquipment), "AttachItem", (Type[])null, (Type[])null);

		private static readonly MethodInfo lod = AccessTools.Method(typeof(VisEquipment), "UpdateLodgroup", (Type[])null, (Type[])null);

		private static void Postfix(VisEquipment __instance)
		{
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			ZNetView val = vista.Invoke(__instance);
			if ((Object)(object)val == (Object)null || !val.IsValid())
			{
				return;
			}
			ZDO zDO = val.GetZDO();
			if (!desenhos.TryGetValue(__instance, out var value))
			{
				if (zDO.GetInt("coldre_p_r", 0) == 0 && zDO.GetInt("coldre_p_l", 0) == 0)
				{
					return;
				}
				value = new Desenho();
				desenhos.Add(__instance, value);
			}
			Mover(__instance, value, instDir.Invoke(__instance), zDO.GetInt("coldre_p_r", 0), ref value.dir, ref value.lugarDir);
			Mover(__instance, value, instEsq.Invoke(__instance), zDO.GetInt("coldre_p_l", 0), ref value.esq, ref value.lugarEsq);
			bool flag = false;
			for (int i = 0; i < 2; i++)
			{
				int num = zDO.GetInt(Costas.ChaveHash[i], 0);
				int num2 = zDO.GetInt(Costas.ChaveVariante[i], 0);
				int num3 = zDO.GetInt(Costas.ChaveQualidade[i], 0);
				int num4 = zDO.GetInt(Costas.ChaveLugar[i], 0);
				if (value.hash[i] == num && value.variante[i] == num2 && value.qualidade[i] == num3 && value.lugar[i] == num4)
				{
					continue;
				}
				flag = true;
				if ((Object)(object)value.obj[i] != (Object)null)
				{
					Object.Destroy((Object)(object)value.obj[i]);
				}
				value.obj[i] = null;
				value.hash[i] = num;
				value.variante[i] = num2;
				value.qualidade[i] = num3;
				value.lugar[i] = num4;
				if (num != 0)
				{
					Transform val2 = Junta(__instance, value, num4);
					if ((Object)(object)val2 != (Object)null)
					{
						value.obj[i] = (GameObject)anexar.Invoke(__instance, new object[6] { num, num2, val2, false, true, num3 });
					}
				}
			}
			if (flag && lod != null)
			{
				lod.Invoke(__instance, null);
			}
		}

		private static void Mover(VisEquipment v, Desenho d, GameObject obj, int lugar, ref GameObject ultimo, ref int ultimoLugar)
		{
			if ((Object)(object)obj == (Object)(object)ultimo && lugar == ultimoLugar)
			{
				return;
			}
			ultimo = obj;
			ultimoLugar = lugar;
			if (!((Object)(object)obj == (Object)null) && lugar != 0)
			{
				Transform val = Junta(v, d, lugar);
				if ((Object)(object)val != (Object)null)
				{
					obj.transform.SetParent(val, false);
				}
			}
		}

		private static Transform Junta(VisEquipment v, Desenho d, int e)
		{
			return (Transform)(e switch
			{
				1 => v.m_backMelee, 
				2 => v.m_backTwohandedMelee, 
				3 => v.m_backBow, 
				4 => v.m_backTool, 
				5 => v.m_backAtgeir, 
				6 => v.m_backShield, 
				7 => CinturaEsq(v, d), 
				_ => null, 
			});
		}

		private static Transform CinturaEsq(VisEquipment v, Desenho d)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)d.cinturaEsq != (Object)null)
			{
				return d.cinturaEsq;
			}
			Transform backTool = v.m_backTool;
			if ((Object)(object)backTool == (Object)null)
			{
				return null;
			}
			GameObject val = new GameObject("ColdreCinturaEsq");
			val.transform.SetParent(backTool.parent, false);
			Vector3 localPosition = backTool.localPosition;
			Quaternion localRotation = backTool.localRotation;
			val.transform.localPosition = new Vector3(0f - localPosition.x, localPosition.y, localPosition.z);
			val.transform.localRotation = new Quaternion(localRotation.x, 0f - localRotation.y, 0f - localRotation.z, localRotation.w);
			val.transform.localScale = backTool.localScale;
			d.cinturaEsq = val.transform;
			return d.cinturaEsq;
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem")]
	internal static class EquiparPatch
	{
		internal struct Antes
		{
			public bool valido;

			public ItemData dir;

			public ItemData esq;

			public List<ItemData> costas;
		}

		private static void Prefix(Humanoid __instance, ItemData item, out Antes __state)
		{
			__state = default(Antes);
			if (Maos.EhLocal(__instance) && Maos.EhItemDeMao(item))
			{
				if (!Coldre.Ativo.Value || !Coldre.GuardarAoTrocar.Value)
				{
					Costas.Limpar(__instance);
				}
				else if (!__instance.IsItemEquiped(item))
				{
					__state.valido = true;
					__state.dir = Maos.Direita(__instance);
					__state.esq = Maos.Esquerda(__instance);
					__state.costas = Costas.Lista(__instance);
				}
			}
		}

		private static void Postfix(Humanoid __instance, ItemData item, bool __result, Antes __state)
		{
			if (!__state.valido)
			{
				return;
			}
			List<ItemData> list = new List<ItemData>();
			if (__result)
			{
				ItemData val = Maos.Direita(__instance);
				ItemData val2 = Maos.Esquerda(__instance);
				if (__state.dir != null && __state.dir != val && __state.dir != val2)
				{
					Costas.Junta(list, __state.dir);
				}
				if (__state.esq != null && __state.esq != val && __state.esq != val2)
				{
					Costas.Junta(list, __state.esq);
				}
			}
			foreach (ItemData costa in __state.costas)
			{
				Costas.Junta(list, costa);
			}
			Costas.Distribuir(__instance, list);
		}
	}
	internal static class Toques
	{
		public static bool ferramentaNaMao;

		public static int quadroDoBotao = -1;

		public static float horaDoPrimeiro = -1f;

		public static List<ItemData> antes = new List<ItemData>();

		private static readonly MethodInfo aceitaComando = AccessTools.Method(typeof(Player), "TakeInput", (Type[])null, (Type[])null);

		public static int quadroDaTroca = -1;

		private static bool alternou;

		public static bool BotaoApertadoNesteQuadro => quadroDoBotao == Time.frameCount;

		public static bool ModoTrocar => Coldre.Modo.Value == "Trocar";

		public static void Esquece()
		{
			horaDoPrimeiro = -1f;
			antes.Clear();
		}

		public static bool Escolher(Humanoid h, List<ItemData> lista, out ItemData arma, out ItemData escudo)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Invalid comparison between Unknown and I4
			arma = null;
			escudo = null;
			foreach (ItemData listum in lista)
			{
				if (!Maos.PodeIrParaAsCostas(h, listum))
				{
					continue;
				}
				if ((int)listum.m_shared.m_itemType == 5)
				{
					if (escudo == null)
					{
						escudo = listum;
					}
				}
				else
				{
					arma = listum;
				}
			}
			if (arma != null && (int)arma.m_shared.m_itemType != 3 && (int)arma.m_shared.m_itemType != 15)
			{
				escudo = null;
			}
			if (arma == null)
			{
				return escudo != null;
			}
			return true;
		}

		public static bool Sacar(Humanoid h, ItemData arma, ItemData escudo)
		{
			bool flag = false;
			if (arma != null)
			{
				flag |= h.EquipItem(arma, true);
			}
			if (escudo != null)
			{
				flag |= h.EquipItem(escudo, true);
			}
			if (flag)
			{
				Maos.AnimacaoDeSacar(h);
			}
			return flag;
		}

		public static void TrocarNoToque(Player p)
		{
			if (ModoTrocar && BotaoApertadoNesteQuadro && !((Character)p).InAttack() && !((Character)p).InDodge() && (Maos.Direita((Humanoid)(object)p) != null || Maos.Esquerda((Humanoid)(object)p) != null))
			{
				ItemData arma;
				ItemData escudo;
				if (horaDoPrimeiro >= 0f && Time.unscaledTime - horaDoPrimeiro <= Coldre.Janela.Value)
				{
					Esquece();
				}
				else if (Escolher((Humanoid)(object)p, Costas.Lista((Humanoid)(object)p), out arma, out escudo) && Sacar((Humanoid)(object)p, arma, escudo))
				{
					quadroDaTroca = Time.frameCount;
					antes.Clear();
					horaDoPrimeiro = Time.unscaledTime;
				}
			}
		}

		public static void ConferirSegurar(Player p)
		{
			float value = Coldre.SegurarParaAlternar.Value;
			bool button = ZInput.GetButton("JoyHide");
			bool button2 = ZInput.GetButton("Hide");
			if (!button && !button2)
			{
				alternou = false;
			}
			else if (!(value <= 0f) && !alternou && !Hud.InRadial() && !(Mathf.Max(button ? ZInput.GetButtonPressedTimer("JoyHide") : 0f, button2 ? ZInput.GetButtonPressedTimer("Hide") : 0f) < value))
			{
				alternou = true;
				Coldre.Modo.Value = (ModoTrocar ? "Guardar" : "Trocar");
				Esquece();
			}
		}

		public static bool GuardarFerramentaNoControle(Player p)
		{
			if (!BotaoApertadoNesteQuadro || !ferramentaNaMao || !((Character)p).InPlaceMode() || ((Character)p).InAttack() || !(bool)aceitaComando.Invoke(p, null))
			{
				return false;
			}
			if (ZInput.GetButtonDown("Hide") || Hud.IsPieceSelectionVisible())
			{
				return false;
			}
			return true;
		}

		public static bool LeuBotaoDeGuardar()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (Hud.InRadial())
			{
				return false;
			}
			bool flag = ZInput.GetButtonUp("JoyHide") && ZInput.GetButtonLastPressedTimer("JoyHide") < 0.33f;
			if ((int)ZInput.InputLayout == 0 || !ZInput.IsGamepadActive())
			{
				if (ZInput.GetButtonDown("Hide"))
				{
					return true;
				}
				if (flag)
				{
					return !ZInput.GetButton("JoyAltKeys");
				}
				return false;
			}
			if (flag)
			{
				return !ZInput.GetButton("JoyAltKeys");
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "Update")]
	internal static class LerBotaoPatch
	{
		private static void Prefix(Player __instance)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			Costas.Conferir(__instance);
			if (!Coldre.Ativo.Value)
			{
				Toques.Esquece();
				return;
			}
			if (Toques.horaDoPrimeiro >= 0f && Time.unscaledTime - Toques.horaDoPrimeiro > Coldre.Janela.Value)
			{
				Toques.Esquece();
			}
			if (Toques.LeuBotaoDeGuardar())
			{
				Toques.quadroDoBotao = Time.frameCount;
			}
			Toques.ferramentaNaMao = ((Character)__instance).InPlaceMode();
			Toques.ConferirSegurar(__instance);
			Toques.TrocarNoToque(__instance);
		}

		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && Coldre.Ativo.Value && Toques.quadroDaTroca != Time.frameCount && Toques.GuardarFerramentaNoControle(__instance))
			{
				((Humanoid)__instance).HideHandItems(false, true);
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "HideHandItems")]
	internal static class GuardarPatch
	{
		internal struct Antes
		{
			public bool valido;

			public ItemData dir;

			public ItemData esq;

			public List<ItemData> costas;
		}

		private static bool Prefix(Humanoid __instance, out Antes __state)
		{
			__state = default(Antes);
			if (!Coldre.Ativo.Value || !Maos.EhLocal(__instance))
			{
				return true;
			}
			if (Toques.quadroDaTroca == Time.frameCount)
			{
				return false;
			}
			if (Maos.Direita(__instance) == null && Maos.Esquerda(__instance) == null)
			{
				return true;
			}
			__state.valido = true;
			__state.dir = Maos.Direita(__instance);
			__state.esq = Maos.Esquerda(__instance);
			__state.costas = Costas.Lista(__instance);
			if (Toques.ModoTrocar || !Coldre.DoisToquesTrocam.Value || !Toques.BotaoApertadoNesteQuadro)
			{
				return true;
			}
			Toques.antes = new List<ItemData>(__state.costas);
			Toques.horaDoPrimeiro = ((Toques.antes.Count > 0) ? Time.unscaledTime : (-1f));
			return true;
		}

		private static void Postfix(Humanoid __instance, Antes __state)
		{
			if (!__state.valido)
			{
				return;
			}
			List<ItemData> list = new List<ItemData>();
			Costas.Junta(list, __state.dir);
			Costas.Junta(list, __state.esq);
			foreach (ItemData costa in __state.costas)
			{
				Costas.Junta(list, costa);
			}
			Costas.Distribuir(__instance, list);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "ShowHandItems")]
	internal static class SacarPatch
	{
		private static bool Prefix(Humanoid __instance)
		{
			if (!Coldre.Ativo.Value || Toques.ModoTrocar || !Coldre.DoisToquesTrocam.Value || !Maos.EhLocal(__instance) || !Toques.BotaoApertadoNesteQuadro)
			{
				return true;
			}
			if (Toques.horaDoPrimeiro < 0f || Time.unscaledTime - Toques.horaDoPrimeiro > Coldre.Janela.Value)
			{
				Toques.Esquece();
				return true;
			}
			List<ItemData> lista = new List<ItemData>(Toques.antes);
			Toques.Esquece();
			if (((Character)__instance).InAttack() || ((Character)__instance).InDodge())
			{
				return true;
			}
			if (!Toques.Escolher(__instance, lista, out var arma, out var escudo))
			{
				return true;
			}
			if (!Toques.Sacar(__instance, arma, escudo))
			{
				return true;
			}
			return false;
		}
	}
}