using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
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: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("MesaDeTrabajo")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.5.0")]
[assembly: AssemblyInformationalVersion("1.0.5")]
[assembly: AssemblyProduct("MesaDeTrabajo")]
[assembly: AssemblyTitle("MesaDeTrabajo")]
[assembly: AssemblyVersion("1.0.5.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 MesaDeTrabajo
{
	internal static class AlcanceEstacion
	{
		internal const float RadioBaseVanilla = 20f;

		internal const float RadioPorMejoraVanilla = 4f;

		internal const float DistanciaConexionVanilla = 10f;

		internal const float SeparacionVanilla = 2f;

		private static readonly FieldInfo CampoEstaciones = AccessTools.Field(typeof(CraftingStation), "m_allStations");

		private static readonly FieldInfo CampoMejoras = AccessTools.Field(typeof(StationExtension), "m_allExtensions");

		internal static void Aplicar(CraftingStation estacion)
		{
			MesaDeTrabajoPlugin instancia = MesaDeTrabajoPlugin.Instancia;
			if (!((Object)(object)instancia == (Object)null) && !((Object)(object)estacion == (Object)null))
			{
				estacion.m_rangeBuild = instancia.RadioArea;
				estacion.m_extraRangePerLevel = instancia.RadioPorMejora;
			}
		}

		internal static void Aplicar(StationExtension mejora)
		{
			MesaDeTrabajoPlugin instancia = MesaDeTrabajoPlugin.Instancia;
			if (!((Object)(object)instancia == (Object)null) && !((Object)(object)mejora == (Object)null))
			{
				mejora.m_maxStationDistance = instancia.DistanciaConexion;
			}
		}

		internal static List<CraftingStation> Estaciones()
		{
			return ((CampoEstaciones != null) ? (CampoEstaciones.GetValue(null) as List<CraftingStation>) : null) ?? new List<CraftingStation>();
		}

		internal static void AplicarAloYaColocado()
		{
			List<CraftingStation> list = ((CampoEstaciones != null) ? (CampoEstaciones.GetValue(null) as List<CraftingStation>) : null);
			if (list != null)
			{
				foreach (CraftingStation item in list)
				{
					Aplicar(item);
				}
			}
			List<StationExtension> list2 = ((CampoMejoras != null) ? (CampoMejoras.GetValue(null) as List<StationExtension>) : null);
			if (list2 == null)
			{
				return;
			}
			foreach (StationExtension item2 in list2)
			{
				Aplicar(item2);
			}
		}

		internal static void AplicarAlosPrefabs(ZNetScene escena)
		{
			if ((Object)(object)escena == (Object)null || escena.m_prefabs == null)
			{
				return;
			}
			foreach (GameObject prefab in escena.m_prefabs)
			{
				if (!((Object)(object)prefab == (Object)null))
				{
					Aplicar(prefab.GetComponent<CraftingStation>());
					Aplicar(prefab.GetComponent<StationExtension>());
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	internal static class ParchePrefabsEstacion
	{
		private static void Postfix(ZNetScene __instance)
		{
			AlcanceEstacion.AplicarAlosPrefabs(__instance);
		}
	}
	[HarmonyPatch(typeof(CraftingStation), "Start")]
	internal static class ParcheAlcanceEstacion
	{
		private static void Postfix(CraftingStation __instance)
		{
			AlcanceEstacion.Aplicar(__instance);
		}
	}
	[HarmonyPatch(typeof(StationExtension), "Awake")]
	internal static class ParcheAlcanceMejora
	{
		private static void Postfix(StationExtension __instance)
		{
			AlcanceEstacion.Aplicar(__instance);
		}
	}
	[HarmonyPatch(typeof(StationExtension), "OtherExtensionInRange")]
	internal static class ParcheSeparacionMejoras
	{
		private static void Prefix(ref float radius)
		{
			MesaDeTrabajoPlugin instancia = MesaDeTrabajoPlugin.Instancia;
			if ((Object)(object)instancia != (Object)null)
			{
				radius = instancia.SeparacionMejoras;
			}
		}
	}
	internal static class AsistenteBase
	{
		private struct Zona
		{
			internal readonly Vector3 Centro;

			internal readonly float RadioAlCuadrado;

			internal Zona(Vector3 centro, float radio)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				Centro = centro;
				RadioAlCuadrado = radio * radio;
			}
		}

		private const int MaximoReparacionesPorCiclo = 25;

		private const int MaximoRecogidasPorCiclo = 40;

		private static readonly FieldInfo CampoObjetosSuelo = AccessTools.Field(typeof(ItemDrop), "s_instances");

		private static readonly FieldInfo CampoNacimiento = AccessTools.Field(typeof(ItemDrop), "m_spawnTime");

		private static readonly MethodInfo MetodoGuardarSuelo = AccessTools.Method(typeof(ItemDrop), "Save", (Type[])null, (Type[])null);

		private static float _proximoCiclo;

		internal static void Actualizar()
		{
			MesaDeTrabajoPlugin instancia = MesaDeTrabajoPlugin.Instancia;
			if ((Object)(object)instancia == (Object)null || (!instancia.RepararBase && !instancia.RecogerDelSuelo) || Time.time < _proximoCiclo)
			{
				return;
			}
			_proximoCiclo = Time.time + instancia.IntervaloAsistente;
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			List<Zona> list = ZonasDeBase();
			if (list.Count != 0)
			{
				int reparadas = (instancia.RepararBase ? Reparar(list) : 0);
				int guardados = (instancia.RecogerDelSuelo ? Recoger(list, instancia) : 0);
				if (instancia.AvisosAsistente)
				{
					Avisar(reparadas, guardados);
				}
			}
		}

		private static List<Zona> ZonasDeBase()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			List<Zona> list = new List<Zona>();
			foreach (CraftingStation item in AlcanceEstacion.Estaciones())
			{
				if (!((Object)(object)item == (Object)null))
				{
					float stationBuildRange = item.GetStationBuildRange();
					if (stationBuildRange > 0f)
					{
						list.Add(new Zona(((Component)item).transform.position, stationBuildRange));
					}
				}
			}
			return list;
		}

		private static bool Dentro(List<Zona> zonas, Vector3 punto)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			foreach (Zona zona in zonas)
			{
				Vector3 val = punto - zona.Centro;
				if (((Vector3)(ref val)).sqrMagnitude <= zona.RadioAlCuadrado)
				{
					return true;
				}
			}
			return false;
		}

		private static int Reparar(List<Zona> zonas)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (WearNTear allInstance in WearNTear.GetAllInstances())
			{
				if (num >= 25)
				{
					break;
				}
				if (!((Object)(object)allInstance == (Object)null) && !(allInstance.GetHealthPercentage() >= 1f))
				{
					Vector3 position = ((Component)allInstance).transform.position;
					if (Dentro(zonas, position) && PrivateArea.CheckAccess(position, 0f, false, false) && allInstance.Repair())
					{
						num++;
					}
				}
			}
			return num;
		}

		private static int Recoger(List<Zona> zonas, MesaDeTrabajoPlugin plugin)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			List<ItemDrop> list = ((CampoObjetosSuelo != null) ? (CampoObjetosSuelo.GetValue(null) as List<ItemDrop>) : null);
			if (list == null || list.Count == 0)
			{
				return 0;
			}
			List<Container> list2 = Cofres.Utilizables((Vector3 punto) => Dentro(zonas, punto));
			if (list2.Count == 0)
			{
				return 0;
			}
			int num = 0;
			HashSet<Container> hashSet = new HashSet<Container>();
			foreach (ItemDrop item in new List<ItemDrop>(list))
			{
				if (num >= 40)
				{
					break;
				}
				if (!Recogible(item, zonas, plugin))
				{
					continue;
				}
				if (!item.CanPickup(true))
				{
					item.RequestOwn();
					continue;
				}
				item.Load();
				ItemData itemData = item.m_itemData;
				int stack = itemData.m_stack;
				int num2 = Guardar(list2, ((Component)item).transform.position, itemData, hashSet);
				if (num2 <= 0)
				{
					continue;
				}
				if (num2 >= stack)
				{
					ZNetScene.instance.Destroy(((Component)item).gameObject);
				}
				else
				{
					itemData.m_stack = stack - num2;
					if (MetodoGuardarSuelo != null)
					{
						MetodoGuardarSuelo.Invoke(item, null);
					}
				}
				num++;
			}
			foreach (Container item2 in hashSet)
			{
				Cofres.Guardar(item2);
			}
			return num;
		}

		private static bool Recogible(ItemDrop suelo, List<Zona> zonas, MesaDeTrabajoPlugin plugin)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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: Invalid comparison between Unknown and I4
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)suelo == (Object)null || !suelo.m_autoPickup)
			{
				return false;
			}
			ItemData itemData = suelo.m_itemData;
			if (itemData == null || itemData.m_shared == null || itemData.m_stack <= 0)
			{
				return false;
			}
			if ((Object)(object)((Component)suelo).GetComponent<Piece>() != (Object)null)
			{
				return false;
			}
			Vector3 position = ((Component)suelo).transform.position;
			if (!Dentro(zonas, position))
			{
				return false;
			}
			if (!plugin.RecogerComida && (int)itemData.m_shared.m_itemType == 2)
			{
				return false;
			}
			if (plugin.NoRecoger.Contains(NombrePrefab(((Component)suelo).gameObject)))
			{
				return false;
			}
			if (CampoNacimiento != null && Time.time - (float)CampoNacimiento.GetValue(suelo) < plugin.SegundosEnSuelo)
			{
				return false;
			}
			return PrivateArea.CheckAccess(position, 0f, false, false);
		}

		private static string NombrePrefab(GameObject objeto)
		{
			string name = ((Object)objeto).name;
			int num = name.IndexOf("(Clone)", StringComparison.Ordinal);
			return ((num >= 0) ? name.Substring(0, num) : name).Trim().ToLowerInvariant();
		}

		private static int Guardar(List<Container> cofres, Vector3 origen, ItemData dato, HashSet<Container> tocados)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			cofres.Sort(delegate(Container a, Container b)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: 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_002d: 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)
				Vector3 val2 = ((Component)a).transform.position - origen;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				val2 = ((Component)b).transform.position - origen;
				return sqrMagnitude.CompareTo(((Vector3)(ref val2)).sqrMagnitude);
			});
			int num = dato.m_stack;
			string name = dato.m_shared.m_name;
			for (int num2 = 0; num2 < 2; num2++)
			{
				if (num <= 0)
				{
					break;
				}
				foreach (Container cofre in cofres)
				{
					if (num <= 0)
					{
						break;
					}
					Inventory inventory = cofre.GetInventory();
					Cofres.Recargar(cofre);
					if (!((num2 == 0) ? inventory.ContainsItemByName(name) : (inventory.GetAllItems().Count == 0)))
					{
						continue;
					}
					int num3 = CuantoCabe(inventory, dato, num);
					if (num3 > 0)
					{
						ItemData val = dato.Clone();
						val.m_stack = num3;
						Cofres.Reclamar(cofre);
						if (inventory.AddItem(val))
						{
							tocados.Add(cofre);
							num -= num3;
						}
					}
				}
			}
			return dato.m_stack - num;
		}

		private static int CuantoCabe(Inventory inventario, ItemData dato, int maximo)
		{
			ItemData val = dato.Clone();
			int num = 0;
			int num2 = maximo;
			while (num < num2)
			{
				int num3 = (val.m_stack = (num + num2 + 1) / 2);
				if (inventario.CanAddItem(val, num3))
				{
					num = num3;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return num;
		}

		private static void Avisar(int reparadas, int guardados)
		{
			List<string> list = new List<string>();
			if (reparadas > 0)
			{
				list.Add((reparadas == 1) ? "1 pieza reparada" : (reparadas + " piezas reparadas"));
			}
			if (guardados > 0)
			{
				list.Add((guardados == 1) ? "1 objeto guardado en cofres" : (guardados + " objetos guardados en cofres"));
			}
			MessageHud instance = MessageHud.instance;
			if (list.Count > 0 && (Object)(object)instance != (Object)null)
			{
				instance.ShowMessage((MessageType)1, "Base: " + string.Join(" · ", list.ToArray()), 0, (Sprite)null, false, false);
			}
		}
	}
	internal static class Cofres
	{
		private static readonly MethodInfo MetodoRecargar = AccessTools.Method(typeof(Container), "CheckForChanges", (Type[])null, (Type[])null);

		private static readonly MethodInfo MetodoGuardar = AccessTools.Method(typeof(Container), "Save", (Type[])null, (Type[])null);

		private static readonly MethodInfo MetodoAcceso = AccessTools.Method(typeof(Container), "CheckAccess", (Type[])null, (Type[])null);

		internal static List<Container> Utilizables(Func<Vector3, bool> dentro)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			List<Container> list = new List<Container>();
			long num = IdJugador();
			Container[] array = Object.FindObjectsByType<Container>((FindObjectsSortMode)0);
			foreach (Container val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).GetComponent<Piece>() == (Object)null) && !((Object)(object)((Component)val).GetComponentInParent<Vagon>() != (Object)null) && !((Object)(object)((Component)val).GetComponentInParent<Ship>() != (Object)null) && dentro(((Component)val).transform.position) && SigueUtilizable(val) && (!(MetodoAcceso != null) || (bool)MetodoAcceso.Invoke(val, new object[1] { num })))
				{
					list.Add(val);
				}
			}
			return list;
		}

		internal static bool SigueUtilizable(Container cofre)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cofre == (Object)null || cofre.IsInUse() || cofre.GetInventory() == null)
			{
				return false;
			}
			ZNetView component = ((Component)cofre).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				return PrivateArea.CheckAccess(((Component)cofre).transform.position, 0f, false, false);
			}
			return false;
		}

		internal static void Recargar(Container cofre)
		{
			if (MetodoRecargar != null)
			{
				MetodoRecargar.Invoke(cofre, null);
			}
		}

		internal static void Reclamar(Container cofre)
		{
			((Component)cofre).GetComponent<ZNetView>().ClaimOwnership();
		}

		internal static void Guardar(Container cofre)
		{
			if (MetodoGuardar != null)
			{
				MetodoGuardar.Invoke(cofre, null);
			}
		}

		private static long IdJugador()
		{
			Game instance = Game.instance;
			PlayerProfile val = (((Object)(object)instance != (Object)null) ? instance.GetPlayerProfile() : null);
			if (val == null)
			{
				return 0L;
			}
			return val.GetPlayerID();
		}
	}
	internal static class SinEstacion
	{
		private static Piece _pieza;

		private static CraftingStation _guardada;

		private static int _profundidad;

		internal static void Quitar(Piece pieza)
		{
			if (_profundidad++ > 0)
			{
				return;
			}
			_pieza = null;
			_guardada = null;
			MesaDeTrabajoPlugin instancia = MesaDeTrabajoPlugin.Instancia;
			if (!((Object)(object)instancia == (Object)null) && !instancia.LimiteAreaActivo && !((Object)(object)pieza == (Object)null))
			{
				CraftingStation craftingStation = pieza.m_craftingStation;
				if (!((Object)(object)craftingStation == (Object)null))
				{
					_pieza = pieza;
					_guardada = craftingStation;
					pieza.m_craftingStation = null;
				}
			}
		}

		internal static void Devolver()
		{
			if (_profundidad > 0)
			{
				_profundidad--;
			}
			if (_profundidad <= 0)
			{
				if ((Object)(object)_pieza != (Object)null)
				{
					_pieza.m_craftingStation = _guardada;
				}
				_pieza = null;
				_guardada = null;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "HaveRequirements", new Type[]
	{
		typeof(Piece),
		typeof(RequirementMode)
	})]
	internal static class ParcheRequisitosPieza
	{
		private static void Prefix(Piece piece)
		{
			SinEstacion.Quitar(piece);
		}

		private static void Finalizer()
		{
			SinEstacion.Devolver();
		}
	}
	[HarmonyPatch(typeof(Player), "CheckCanRemovePiece")]
	internal static class ParcheQuitarPieza
	{
		private static void Prefix(Piece piece)
		{
			SinEstacion.Quitar(piece);
		}

		private static void Finalizer()
		{
			SinEstacion.Devolver();
		}
	}
	[HarmonyPatch(typeof(Hud), "SetupPieceInfo")]
	internal static class ParcheCartelPieza
	{
		private static void Prefix(Piece piece)
		{
			SinEstacion.Quitar(piece);
		}

		private static void Finalizer()
		{
			SinEstacion.Devolver();
		}
	}
	[BepInPlugin("altairfernando.mesadetrabajo", "MesaDeTrabajo", "1.0.5")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MesaDeTrabajoPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "altairfernando.mesadetrabajo";

		public const string PluginName = "MesaDeTrabajo";

		public const string PluginVersion = "1.0.5";

		private const float IntervaloReparacion = 1f;

		internal static MesaDeTrabajoPlugin Instancia;

		private ConfigEntry<bool> _limiteArea;

		private ConfigEntry<float> _radioArea;

		private ConfigEntry<float> _radioPorMejora;

		private ConfigEntry<float> _distanciaConexion;

		private ConfigEntry<float> _separacionMejoras;

		private ConfigEntry<bool> _autoReparar;

		private ConfigEntry<bool> _repararBase;

		private ConfigEntry<bool> _recogerDelSuelo;

		private ConfigEntry<float> _intervaloAsistente;

		private ConfigEntry<float> _segundosEnSuelo;

		private ConfigEntry<bool> _recogerComida;

		private ConfigEntry<string> _noRecoger;

		private ConfigEntry<bool> _avisosAsistente;

		private ConfigEntry<bool> _cofresEnEpicLoot;

		private ConfigEntry<float> _radioCofresEpicLoot;

		private float _proximaRevisionReparar;

		internal bool CofresEnEpicLoot
		{
			get
			{
				if (_cofresEnEpicLoot != null)
				{
					return _cofresEnEpicLoot.Value;
				}
				return false;
			}
		}

		internal float RadioCofresEpicLoot
		{
			get
			{
				if (_radioCofresEpicLoot == null)
				{
					return 20f;
				}
				return _radioCofresEpicLoot.Value;
			}
		}

		internal bool RepararBase
		{
			get
			{
				if (_repararBase != null)
				{
					return _repararBase.Value;
				}
				return false;
			}
		}

		internal bool RecogerDelSuelo
		{
			get
			{
				if (_recogerDelSuelo != null)
				{
					return _recogerDelSuelo.Value;
				}
				return false;
			}
		}

		internal float IntervaloAsistente
		{
			get
			{
				if (_intervaloAsistente == null)
				{
					return 5f;
				}
				return _intervaloAsistente.Value;
			}
		}

		internal float SegundosEnSuelo
		{
			get
			{
				if (_segundosEnSuelo == null)
				{
					return 5f;
				}
				return _segundosEnSuelo.Value;
			}
		}

		internal bool RecogerComida
		{
			get
			{
				if (_recogerComida != null)
				{
					return _recogerComida.Value;
				}
				return false;
			}
		}

		internal bool AvisosAsistente
		{
			get
			{
				if (_avisosAsistente != null)
				{
					return _avisosAsistente.Value;
				}
				return false;
			}
		}

		internal HashSet<string> NoRecoger { get; private set; } = new HashSet<string>();

		internal bool LimiteAreaActivo
		{
			get
			{
				if (_limiteArea != null)
				{
					return _limiteArea.Value;
				}
				return true;
			}
		}

		internal float RadioArea
		{
			get
			{
				if (_radioArea == null)
				{
					return 20f;
				}
				return _radioArea.Value;
			}
		}

		internal float RadioPorMejora
		{
			get
			{
				if (_radioPorMejora == null)
				{
					return 4f;
				}
				return _radioPorMejora.Value;
			}
		}

		internal float DistanciaConexion
		{
			get
			{
				if (_distanciaConexion == null)
				{
					return 10f;
				}
				return _distanciaConexion.Value;
			}
		}

		internal float SeparacionMejoras
		{
			get
			{
				if (_separacionMejoras == null)
				{
					return 2f;
				}
				return _separacionMejoras.Value;
			}
		}

		private void Awake()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			Instancia = this;
			_limiteArea = ((BaseUnityPlugin)this).Config.Bind<bool>("1 - Area de mesa", "LimitarArea", true, "Si lo apagas, la mesa deja de hacer falta: construyes en cualquier sitio, aunque no tengas ninguna cerca ni cargada.");
			_radioArea = ((BaseUnityPlugin)this).Config.Bind<float>("1 - Area de mesa", "Radio", 20f, new ConfigDescription("Radio en metros del area de una estacion sin mejoras. 20 es el valor de fabrica. Se ignora si LimitarArea esta apagado.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 200f), Array.Empty<object>()));
			_radioPorMejora = ((BaseUnityPlugin)this).Config.Bind<float>("1 - Area de mesa", "RadioPorMejora", 4f, new ConfigDescription("Cuantos metros suma al area cada mejora conectada a la estacion. 4 es el valor de fabrica.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()));
			_distanciaConexion = ((BaseUnityPlugin)this).Config.Bind<float>("2 - Mejoras de estacion", "DistanciaConexion", 10f, new ConfigDescription("Hasta que distancia una mejora (yunque, curtidor, mesa de afilar...) sigue conectando con su estacion. 10 es el valor de fabrica.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
			_separacionMejoras = ((BaseUnityPlugin)this).Config.Bind<float>("2 - Mejoras de estacion", "SeparacionMinima", 2f, new ConfigDescription("Hueco obligatorio en metros entre dos mejoras. 2 es el valor de fabrica; con 0 se pueden pegar unas a otras.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			_autoReparar = ((BaseUnityPlugin)this).Config.Bind<bool>("3 - Reparacion", "AutoReparar", true, "Repara solo todo lo reparable al acercarte a una estacion utilizable (con techo).");
			_repararBase = ((BaseUnityPlugin)this).Config.Bind<bool>("4 - Asistente de base", "RepararBase", true, "Repara solas las piezas dañadas (paredes, suelos, techos...) dentro del area de tus estaciones de trabajo. Respeta las guardas de otros jugadores.");
			_recogerDelSuelo = ((BaseUnityPlugin)this).Config.Bind<bool>("4 - Asistente de base", "RecogerDelSuelo", true, "Guarda en cofres lo que cae al suelo dentro del area de tus estaciones. Va a un cofre que ya tenga ese objeto o, si no, a uno vacio; nunca mezcla en un cofre con otras cosas. Si no hay sitio, se queda en el suelo.");
			_intervaloAsistente = ((BaseUnityPlugin)this).Config.Bind<float>("4 - Asistente de base", "CadaCuantosSegundos", 5f, new ConfigDescription("Cada cuanto repasa la base.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 60f), Array.Empty<object>()));
			_segundosEnSuelo = ((BaseUnityPlugin)this).Config.Bind<float>("4 - Asistente de base", "SegundosEnElSuelo", 5f, new ConfigDescription("Cuanto tiene que llevar un objeto en el suelo antes de recogerlo, para que lo que sueltas a proposito no desaparezca al instante.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 300f), Array.Empty<object>()));
			_recogerComida = ((BaseUnityPlugin)this).Config.Bind<bool>("4 - Asistente de base", "RecogerComida", false, "Apagado por defecto: los animales que estas domando comen del suelo, y recogerles la comida rompe la doma.");
			_noRecoger = ((BaseUnityPlugin)this).Config.Bind<string>("4 - Asistente de base", "NoRecoger", "ChickenEgg", "Prefabs que se dejan en el suelo, separados por coma. Los huevos vienen puestos porque solo eclosionan si se quedan en el suelo.");
			_avisosAsistente = ((BaseUnityPlugin)this).Config.Bind<bool>("4 - Asistente de base", "Avisos", true, "Avisa arriba a la izquierda de lo que ha reparado y guardado.");
			RecargarNoRecoger();
			_noRecoger.SettingChanged += delegate
			{
				RecargarNoRecoger();
			};
			_cofresEnEpicLoot = ((BaseUnityPlugin)this).Config.Bind<bool>("5 - Epic Loot", "CofresCuentan", true, "La mesa de Epic Loot cuenta y gasta los materiales de los cofres cercanos, no solo los de tu inventario. El objeto que encantas sigue teniendo que estar en tu inventario. Sin Epic Loot instalado no hace nada.");
			_radioCofresEpicLoot = ((BaseUnityPlugin)this).Config.Bind<float>("5 - Epic Loot", "Radio", 20f, new ConfigDescription("Hasta cuantos metros de ti cuenta un cofre.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 100f), Array.Empty<object>()));
			EventHandler eventHandler = delegate
			{
				AlcanceEstacion.AplicarAloYaColocado();
			};
			_radioArea.SettingChanged += eventHandler;
			_radioPorMejora.SettingChanged += eventHandler;
			_distanciaConexion.SettingChanged += eventHandler;
			new Harmony("altairfernando.mesadetrabajo").PatchAll(Assembly.GetExecutingAssembly());
			ProveedorEpicLoot.Registrar(((BaseUnityPlugin)this).Logger);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"MesaDeTrabajo 1.0.5 cargado.");
		}

		private void RecargarNoRecoger()
		{
			HashSet<string> hashSet = new HashSet<string>();
			string[] array = (_noRecoger.Value ?? string.Empty).Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim().ToLowerInvariant();
				if (text.Length > 0)
				{
					hashSet.Add(text);
				}
			}
			NoRecoger = hashSet;
		}

		private void Update()
		{
			AsistenteBase.Actualizar();
			if (!_autoReparar.Value || Time.time < _proximaRevisionReparar)
			{
				return;
			}
			_proximaRevisionReparar = Time.time + 1f;
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				int num = Reparacion.Intentar(localPlayer);
				if (num > 0)
				{
					Mensaje((num == 1) ? "Reparado 1 objeto" : ("Reparados " + num + " objetos"));
				}
			}
		}

		private static void Mensaje(string texto)
		{
			MessageHud instance = MessageHud.instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.ShowMessage((MessageType)2, texto, 0, (Sprite)null, false, false);
			}
		}
	}
	internal static class ProveedorEpicLoot
	{
		internal const string GuidEpicLoot = "randyknapp.mods.epicloot";

		private const string IdProveedor = "altairfernando.mesadetrabajo.cofres";

		private const float VidaLista = 1f;

		private static List<Container> _cercanos = new List<Container>();

		private static float _listaHasta;

		internal static void Registrar(ManualLogSource registro)
		{
			if (Chainloader.PluginInfos.TryGetValue("randyknapp.mods.epicloot", out var value) && !((Object)(object)value.Instance == (Object)null))
			{
				Type type = ((object)value.Instance).GetType().Assembly.GetType("EpicLoot.API");
				MethodInfo methodInfo = ((type != null) ? type.GetMethod("RegisterInventoryProvider", BindingFlags.Static | BindingFlags.Public) : null);
				if (methodInfo == null)
				{
					registro.LogWarning((object)"Epic Loot está instalado pero su versión no trae la API de proveedores: su mesa no verá los cofres.");
				}
				else if ((bool)methodInfo.Invoke(null, new object[5]
				{
					"altairfernando.mesadetrabajo.cofres",
					null,
					new Func<string, int>(Contar),
					new Func<string, int, int>(Quitar),
					null
				}))
				{
					registro.LogInfo((object)"Epic Loot: su mesa cuenta los materiales de los cofres cercanos.");
				}
				else
				{
					registro.LogWarning((object)"Epic Loot rechazó el proveedor de cofres; mira su línea en el log.");
				}
			}
		}

		private static int Contar(string nombre)
		{
			int num = 0;
			foreach (Container item in Cercanos())
			{
				num += item.GetInventory().CountItems(nombre, -1, true);
			}
			return num;
		}

		private static int Quitar(string nombre, int cantidad)
		{
			int num = 0;
			foreach (Container item in Cercanos())
			{
				if (num >= cantidad)
				{
					break;
				}
				if (!Cofres.SigueUtilizable(item))
				{
					continue;
				}
				Cofres.Recargar(item);
				Inventory inventory = item.GetInventory();
				int num2 = inventory.CountItems(nombre, -1, true);
				if (num2 > 0)
				{
					Cofres.Reclamar(item);
					inventory.RemoveItem(nombre, Math.Min(num2, cantidad - num), -1, true);
					int num3 = num2 - inventory.CountItems(nombre, -1, true);
					if (num3 > 0)
					{
						Cofres.Guardar(item);
						num += num3;
					}
				}
			}
			return num;
		}

		private static List<Container> Cercanos()
		{
			//IL_008f: 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)
			MesaDeTrabajoPlugin instancia = MesaDeTrabajoPlugin.Instancia;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)instancia == (Object)null || !instancia.CofresEnEpicLoot || (Object)(object)localPlayer == (Object)null)
			{
				_cercanos.Clear();
				return _cercanos;
			}
			if (Time.time < _listaHasta)
			{
				_cercanos.RemoveAll((Container cofre) => (Object)(object)cofre == (Object)null || cofre.GetInventory() == null);
				return _cercanos;
			}
			_listaHasta = Time.time + 1f;
			Vector3 centro = ((Component)localPlayer).transform.position;
			float radioAlCuadrado = instancia.RadioCofresEpicLoot * instancia.RadioCofresEpicLoot;
			_cercanos = Cofres.Utilizables(delegate(Vector3 punto)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: 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_000c: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = punto - centro;
				return ((Vector3)(ref val)).sqrMagnitude <= radioAlCuadrado;
			});
			_cercanos.Sort(delegate(Container a, Container b)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: 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_002d: 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)
				Vector3 val = ((Component)a).transform.position - centro;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				val = ((Component)b).transform.position - centro;
				return sqrMagnitude.CompareTo(((Vector3)(ref val)).sqrMagnitude);
			});
			foreach (Container cercano in _cercanos)
			{
				Cofres.Recargar(cercano);
			}
			return _cercanos;
		}
	}
	internal static class Reparacion
	{
		private const int MaximoPorIntento = 60;

		private static readonly MethodInfo MetodoRepararUno = AccessTools.Method(typeof(InventoryGui), "RepairOneItem", (Type[])null, (Type[])null);

		private static readonly MethodInfo MetodoHayReparables = AccessTools.Method(typeof(InventoryGui), "HaveRepairableItems", (Type[])null, (Type[])null);

		internal static bool Disponible
		{
			get
			{
				if (MetodoRepararUno != null)
				{
					return MetodoHayReparables != null;
				}
				return false;
			}
		}

		internal static int Intentar(Player jugador)
		{
			if (!Disponible || (Object)(object)jugador == (Object)null)
			{
				return 0;
			}
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return 0;
			}
			CraftingStation currentCraftingStation = jugador.GetCurrentCraftingStation();
			if ((Object)(object)currentCraftingStation == (Object)null || !currentCraftingStation.CheckUsable(jugador, false))
			{
				return 0;
			}
			int i;
			for (i = 0; i < 60; i++)
			{
				if (!HayReparables(instance))
				{
					break;
				}
				float num = DurabilidadTotal(jugador);
				MetodoRepararUno.Invoke(instance, null);
				if (DurabilidadTotal(jugador) <= num)
				{
					break;
				}
			}
			return i;
		}

		private static bool HayReparables(InventoryGui gui)
		{
			object obj = MetodoHayReparables.Invoke(gui, null);
			if (obj is bool)
			{
				return (bool)obj;
			}
			return false;
		}

		private static float DurabilidadTotal(Player jugador)
		{
			Inventory inventory = ((Humanoid)jugador).GetInventory();
			if (inventory == null)
			{
				return 0f;
			}
			float num = 0f;
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem != null && allItem.m_shared != null && allItem.m_shared.m_canBeReparied)
				{
					num += allItem.m_durability;
				}
			}
			return num;
		}
	}
}