using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ConditionalConfigSync;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using VSM.Core.Config;
using VSM.Core.Harmony;
using VSM.Core.Localization;
using VSM.Core.Reflection;
using VSM.Core.Runtime;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: <977d6cca-7cff-4fb7-a12c-37e7012c14b1>IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: <977d6cca-7cff-4fb7-a12c-37e7012c14b1>IgnoresAccessChecksTo("assembly_utils")]
[assembly: <977d6cca-7cff-4fb7-a12c-37e7012c14b1>IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("VSM.AdminPortals")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.4.0")]
[assembly: AssemblyInformationalVersion("0.1.4+ff27bc889ccf218c61c45d3417d48ab708a5ba8f")]
[assembly: AssemblyProduct("VSM.AdminPortals")]
[assembly: AssemblyTitle("VSM.AdminPortals")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.4.0")]
[module: UnverifiableCode]
[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 VSM.AdminPortals
{
	[BepInPlugin("vsm.adminportals", "MEL AdminPortals", "0.1.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class AdminPortalsPlugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		private static ConfigSync s_sync;

		private static CustomSyncedValue<bool> s_gateOk;

		private Harmony _harmony;

		public static ConfigEntry<bool> Enabled;

		public static ConfigEntry<bool> BlockNonAdminPlacement;

		public static ConfigEntry<bool> AdminOnlyTravel;

		public static ConfigEntry<bool> LockTagsForNonAdmins;

		public static ConfigEntry<bool> ServerLock;

		public static ConfigEntry<bool> VerboseLog;

		internal static bool ServerPatchesOk;

		private static readonly Dictionary<string, string> s_spanish = new Dictionary<string, string>
		{
			{ "vsm_adminportals_onlyadmin", "Solo un administrador puede construir portales en este servidor" },
			{ "vsm_adminportals_hover_off", "Portales desactivados: solo funcionan los que construye un administrador" },
			{ "vsm_adminportals_travel_adminonly", "Solo los administradores pueden usar los portales en este servidor" },
			{ "vsm_adminportals_tag_locked", "Solo un administrador puede cambiar el nombre de los portales" }
		};

		public static bool IsConfigReady => s_sync != null && (((ConditionalConfigSync)s_sync).IsSourceOfTruth || ((ConditionalConfigSync)s_sync).InitialSyncDone);

		public static bool Active => Enabled != null && Enabled.Value && IsConfigReady && s_gateOk != null && s_gateOk.Value && (Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey((GlobalKeys)32);

		public static bool LocalIsAdmin => ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer()) || (s_sync != null && ((ConditionalConfigSync)s_sync).IsAdmin);

		private void Awake()
		{
			//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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0044: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			s_sync = new ConfigSync("vsm.adminportals")
			{
				DisplayName = "MEL AdminPortals",
				CurrentVersion = "0.1.4",
				MinimumRequiredVersion = "0.1.4",
				ModRequired = true
			};
			Enabled = Synced<bool>(Bind("1. General", "Enabled", value: true, "Con el modificador de portales de Valheim activo (noportals), funcionan los portales construidos por un administrador. Con false, los portales quedan como en vanilla.", 100));
			BlockNonAdminPlacement = Synced<bool>(Bind("1. General", "BlockNonAdminPlacement", value: true, "Con noportals activo, un jugador que no es administrador no puede colocar portales (aviso, sin gastar materiales). Con false puede colocarlos, pero nunca se conectan.", 99));
			AdminOnlyTravel = Synced<bool>(Bind("1. General", "AdminOnlyTravel", value: false, "Solo los administradores pueden cruzar los portales de administrador. Con false (por defecto) los cruza cualquiera.", 98));
			LockTagsForNonAdmins = Synced<bool>(Bind("1. General", "LockTagsForNonAdmins", value: false, "Solo los administradores pueden cambiar el nombre de un portal mientras noportals esté activo (evita reenlazar portales de admin).", 97));
			ServerLock = Bind("1. General", "ServerLock", value: true, "Bloquea la configuración sincronizada: solo los administradores del servidor pueden cambiarla.", 96);
			((ConditionalConfigSync)s_sync).AddLockingConfigEntry<bool>(ServerLock);
			VerboseLog = Bind("2. Depuración", "VerboseLog", value: false, "Registro detallado de conexiones y desconexiones de portales (local).", 90);
			s_gateOk = new CustomSyncedValue<bool>((ConditionalConfigSync)(object)s_sync, "vsm.adminportals.gate", false, 0, (IEqualityComparer<bool>)null);
			Log.LogInfo((object)("vsm.adminportals 0.1.4 | Valheim " + GameConstants.GameVersionString + " | headless=" + Headless.IsHeadless));
			if (!Headless.IsHeadless)
			{
				VsmLocalization.Register(Log, Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), s_spanish);
			}
			_harmony = new Harmony("vsm.adminportals");
			ServerPatchesOk = PatchUtil.PatchClassSafely(Log, _harmony, typeof(ServerPatches.FindRandomUnconnectedPortalPatch)) & PatchUtil.PatchClassSafely(Log, _harmony, typeof(ServerPatches.ConnectPortalsPatch)) & PatchUtil.PatchClassSafely(Log, _harmony, typeof(ServerPatches.GameStartPatch));
			PatchUtil.PatchClassSafely(Log, _harmony, typeof(ClientPatches.TeleportPatch));
			PatchUtil.PatchClassSafely(Log, _harmony, typeof(ClientPatches.TryPlacePiecePatch));
			PatchUtil.PatchClassSafely(Log, _harmony, typeof(ClientPatches.HoverPatch));
			PatchUtil.PatchClassSafely(Log, _harmony, typeof(ClientPatches.InteractPatch));
			if (PatchUtil.IsDegraded)
			{
				Log.LogError((object)"vsm.adminportals: hay parches sin aplicar (ver arriba). Con noportals, los portales quedan bloqueados como en vanilla.");
			}
		}

		internal static void PublishGate()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && s_gateOk != null)
			{
				if (s_gateOk.Value != ServerPatchesOk)
				{
					s_gateOk.Value = ServerPatchesOk;
				}
				if (!ServerPatchesOk)
				{
					Log.LogError((object)"vsm.adminportals: faltan parches de servidor: con noportals ningún portal se conectará.");
				}
			}
		}

		private ConfigEntry<T> Bind<T>(string section, string key, T value, string description, int order)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			return ((BaseUnityPlugin)this).Config.Bind<T>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order
				}
			}));
		}

		private static ConfigEntry<T> Synced<T>(ConfigEntry<T> entry)
		{
			((ConditionalConfigSync)s_sync).AddConfigEntry<T>(entry, (ConfigSyncMode)0);
			return entry;
		}

		private void OnDestroy()
		{
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
			}
		}

		internal static void Verbose(string message)
		{
			if (VerboseLog != null && VerboseLog.Value && Log != null)
			{
				Log.LogInfo((object)("vsm.adminportals: " + message));
			}
		}
	}
	internal static class ClientPatches
	{
		[HarmonyPatch(typeof(TeleportWorld), "Teleport", new Type[] { typeof(Player) })]
		internal static class TeleportPatch
		{
			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private unsafe static bool Prefix(TeleportWorld __instance, Player player)
			{
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: 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_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				if (!AdminPortalsPlugin.Active || (Object)(object)player == (Object)null)
				{
					return true;
				}
				try
				{
					if (!__instance.TargetFound())
					{
						return true;
					}
					if (AdminPortalsPlugin.AdminOnlyTravel.Value && !AdminPortalsPlugin.LocalIsAdmin)
					{
						((Character)player).Message((MessageType)2, "$vsm_adminportals_travel_adminonly", 0, (Sprite)null, false);
						return false;
					}
					float num = default(float);
					if (ZoneSystem.instance.GetGlobalKey((GlobalKeys)33) && (RandEventSystem.instance.GetBossEvent() != null || (ZoneSystem.instance.GetGlobalKey((GlobalKeys)47, ref num) && num > 0f)))
					{
						((Character)player).Message((MessageType)2, "$msg_blockedbyboss", 0, (Sprite)null, false);
						return false;
					}
					if (!((Humanoid)player).IsTeleportable(__instance.m_allowAllItems))
					{
						((Character)player).Message((MessageType)2, "$msg_noteleport", 0, (Sprite)null, false);
						return false;
					}
					ZDO zDO = ZDOMan.instance.GetZDO(__instance.m_nview.GetZDO().GetConnectionZDOID((ConnectionType)1));
					if (zDO == null)
					{
						return false;
					}
					Vector3 position = zDO.GetPosition();
					Quaternion rotation = zDO.GetRotation();
					Vector3 val = rotation * Vector3.forward;
					((Character)player).TeleportTo(position + val * __instance.m_exitDistance + Vector3.up, rotation, true);
					Game.instance.IncrementPlayerStat((PlayerStatType)15, 1f, false);
					Vector3 val2 = position;
					AdminPortalsPlugin.Verbose("cruza un portal de admin hacia " + ((object)(*(Vector3*)(&val2))/*cast due to .constrained prefix*/).ToString());
					return false;
				}
				catch (Exception ex)
				{
					AdminPortalsPlugin.Log.LogError((object)("vsm.adminportals: Teleport: " + ex.Message));
					return true;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "TryPlacePiece", new Type[] { typeof(Piece) })]
		internal static class TryPlacePiecePatch
		{
			[HarmonyPrefix]
			private static bool Prefix(Player __instance, Piece piece, ref bool __result)
			{
				try
				{
					if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || !Gate.RefusePlacement(AdminPortalsPlugin.Active, AdminPortalsPlugin.BlockNonAdminPlacement.Value, IsPortalPiece(piece), AdminPortalsPlugin.LocalIsAdmin))
					{
						return true;
					}
					((Character)__instance).Message((MessageType)2, "$vsm_adminportals_onlyadmin", 0, (Sprite)null, false);
					__result = false;
					return false;
				}
				catch (Exception ex)
				{
					AdminPortalsPlugin.Log.LogError((object)("vsm.adminportals: colocar: " + ex.Message));
					return true;
				}
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "GetHoverText", new Type[] { })]
		internal static class HoverPatch
		{
			[HarmonyPostfix]
			private static void Postfix(TeleportWorld __instance, ref string __result)
			{
				try
				{
					if (AdminPortalsPlugin.Active && !__instance.HaveTarget())
					{
						__result = __result + "\n" + Localization.instance.Localize("$vsm_adminportals_hover_off");
					}
				}
				catch (Exception)
				{
				}
			}
		}

		[HarmonyPatch(typeof(TeleportWorld), "Interact", new Type[]
		{
			typeof(Humanoid),
			typeof(bool),
			typeof(bool)
		})]
		internal static class InteractPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(Humanoid human, bool hold, ref bool __result)
			{
				if (hold || !AdminPortalsPlugin.Active || !AdminPortalsPlugin.LockTagsForNonAdmins.Value || AdminPortalsPlugin.LocalIsAdmin)
				{
					return true;
				}
				if ((Object)(object)human != (Object)null)
				{
					((Character)human).Message((MessageType)2, "$vsm_adminportals_tag_locked", 0, (Sprite)null, false);
				}
				__result = true;
				return false;
			}
		}

		private static bool IsPortalPiece(Piece piece)
		{
			if ((Object)(object)piece == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)piece).GetComponentInChildren<TeleportWorld>(true) != (Object)null)
			{
				return true;
			}
			return (Object)(object)Game.instance != (Object)null && Game.instance.PortalPrefabHash.Contains(StringExtensionMethods.GetStableHashCode(Utils.GetPrefabName(((Component)piece).gameObject)));
		}
	}
	public static class Gate
	{
		public static bool IsAdminIndex(int creatorIndex, int historyCount, Func<int, bool> isAdminAt)
		{
			if (creatorIndex < 0 || creatorIndex >= historyCount || isAdminAt == null)
			{
				return false;
			}
			return isAdminAt(creatorIndex);
		}

		public static bool KeepPair(bool sourceIsAdmin, bool targetExists, bool targetIsAdmin)
		{
			return sourceIsAdmin && targetExists && targetIsAdmin;
		}

		public static bool RefusePlacement(bool gateActive, bool blockNonAdmins, bool isPortalPiece, bool localIsAdmin)
		{
			return gateActive && blockNonAdmins && isPortalPiece && !localIsAdmin;
		}
	}
	internal static class ServerPatches
	{
		[HarmonyPatch(typeof(Game), "FindRandomUnconnectedPortal", new Type[]
		{
			typeof(List<ZDO>),
			typeof(ZDO),
			typeof(string)
		})]
		internal static class FindRandomUnconnectedPortalPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(Game __instance, List<ZDO> portals, ZDO skip, string tag, ref ZDO __result)
			{
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				if (!Applies)
				{
					return true;
				}
				try
				{
					__result = null;
					if (!IsAdminPortal(skip))
					{
						return false;
					}
					List<ZDO> list = new List<ZDO>();
					foreach (ZDO portal in portals)
					{
						if (portal != skip && portal.GetString(ZDOVars.s_tag, "") == tag && portal.GetConnectionZDOID((ConnectionType)1) == ZDOID.None && !__instance.IsCurrentlyConnectingPortal(portal) && IsAdminPortal(portal))
						{
							list.Add(portal);
						}
					}
					if (list.Count > 0)
					{
						__result = list[Random.Range(0, list.Count)];
						AdminPortalsPlugin.Verbose("empareja portales de admin con nombre '" + tag + "'");
					}
				}
				catch (Exception ex)
				{
					AdminPortalsPlugin.Log.LogError((object)("vsm.adminportals: emparejar: " + ex.Message));
					__result = null;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Game), "ConnectPortals", new Type[] { })]
		internal static class ConnectPortalsPatch
		{
			[HarmonyPrefix]
			private static void Prefix()
			{
				s_adminByIndex.Clear();
			}

			[HarmonyPostfix]
			private static void Postfix(Game __instance)
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: 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_00f5: 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)
				if (!Applies || ZDOMan.instance == null)
				{
					return;
				}
				try
				{
					int num = 0;
					HashSet<ZDOID> hashSet = new HashSet<ZDOID>();
					foreach (ZDO portal in ZDOMan.instance.GetPortalList())
					{
						if (hashSet.Contains(portal.m_uid))
						{
							continue;
						}
						ZDOID connectionZDOID = portal.GetConnectionZDOID((ConnectionType)1);
						if (((ZDOID)(ref connectionZDOID)).IsNone())
						{
							continue;
						}
						ZDO zDO = ZDOMan.instance.GetZDO(connectionZDOID);
						if (!Gate.KeepPair(IsAdminPortal(portal), zDO != null, zDO != null && IsAdminPortal(zDO)))
						{
							__instance.SetConnection(portal, ZDOID.None, false);
							hashSet.Add(portal.m_uid);
							if (zDO != null && zDO.GetConnectionZDOID((ConnectionType)1) == portal.m_uid)
							{
								__instance.SetConnection(zDO, ZDOID.None, false);
								hashSet.Add(zDO.m_uid);
							}
							num++;
						}
					}
					if (num > 0)
					{
						AdminPortalsPlugin.Verbose("desconectados " + num + " portales que no son admin↔admin");
					}
				}
				catch (Exception ex)
				{
					AdminPortalsPlugin.Log.LogError((object)("vsm.adminportals: revisar pares: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(Game), "Start")]
		internal static class GameStartPatch
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				AdminPortalsPlugin.PublishGate();
			}
		}

		private static readonly Dictionary<int, bool> s_adminByIndex = new Dictionary<int, bool>();

		private static bool Applies => (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && AdminPortalsPlugin.Active;

		internal static bool IsAdminPortal(ZDO portal)
		{
			if (portal == null)
			{
				return false;
			}
			World world = ZNet.World;
			if (world == null || world.m_playerHistory == null)
			{
				return false;
			}
			int num = portal.GetInt(ZDOVars.s_creatorIndex, -1);
			if (s_adminByIndex.TryGetValue(num, out var value))
			{
				return value;
			}
			bool flag = Gate.IsAdminIndex(num, world.m_playerHistory.Count, (int i) => IsAdminId(world.m_playerHistory[i].m_id));
			s_adminByIndex[num] = flag;
			return flag;
		}

		private unsafe static bool IsAdminId(PlatformUserID id)
		{
			//IL_0012: 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)
			if (!ZNet.instance.IsDedicated() && UserInfo.GetLocalUser().UserId == id)
			{
				return true;
			}
			return ZNet.instance.IsAdmin(((object)(*(PlatformUserID*)(&id))/*cast due to .constrained prefix*/).ToString());
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "vsm.adminportals";

		public const string PLUGIN_NAME = "MEL AdminPortals";

		public const string PLUGIN_VERSION = "0.1.4";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class <977d6cca-7cff-4fb7-a12c-37e7012c14b1>IgnoresAccessChecksToAttribute : Attribute
	{
		public <977d6cca-7cff-4fb7-a12c-37e7012c14b1>IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace VSM.Core.Ui
{
	internal static class VanillaStyle
	{
		public static TMP_Text TitleFont => ((Object)(object)InventoryGui.instance != (Object)null) ? InventoryGui.instance.m_playerName : null;

		public static TMP_Text BodyFont => (!((Object)(object)InventoryGui.instance != (Object)null)) ? null : (((Object)(object)InventoryGui.instance.m_armor != (Object)null) ? InventoryGui.instance.m_armor : InventoryGui.instance.m_playerName);

		public static Image FindBackground(Transform root, Transform exclude1, Transform exclude2)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Image result = null;
			float num = 0f;
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.sprite == (Object)null)
				{
					continue;
				}
				Transform transform = ((Component)val).transform;
				if ((!((Object)(object)exclude1 != (Object)null) || !transform.IsChildOf(exclude1)) && (!((Object)(object)exclude2 != (Object)null) || !transform.IsChildOf(exclude2)))
				{
					Rect rect = ((Graphic)val).rectTransform.rect;
					float num2 = Mathf.Abs(((Rect)(ref rect)).width * ((Rect)(ref rect)).height);
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		public static bool CopyImage(Image source, Image target)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			if ((Object)(object)source == (Object)null)
			{
				((Graphic)target).color = new Color(0f, 0f, 0f, 0.6f);
				return false;
			}
			target.sprite = source.sprite;
			target.type = source.type;
			((Graphic)target).material = ((Graphic)source).material;
			((Graphic)target).color = ((Graphic)source).color;
			target.fillCenter = source.fillCenter;
			target.pixelsPerUnitMultiplier = source.pixelsPerUnitMultiplier;
			target.preserveAspect = false;
			return true;
		}

		public static Image InventoryBackground(Transform exclude)
		{
			InventoryGui instance = InventoryGui.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_player == (Object)null)
			{
				return null;
			}
			Transform exclude2 = (Transform)(object)(((Object)(object)instance.m_playerGrid != (Object)null) ? instance.m_playerGrid.m_gridRoot : null);
			return FindBackground((Transform)(object)instance.m_player, exclude2, exclude);
		}

		public static void CopyFont(TMP_Text source, TMP_Text target)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)source == (Object)null) && !((Object)(object)target == (Object)null))
			{
				target.font = source.font;
				target.fontSharedMaterial = source.fontSharedMaterial;
				((Graphic)target).color = ((Graphic)source).color;
				target.fontStyle = source.fontStyle;
			}
		}

		public static TextMeshProUGUI NewText(Transform parent, string name, TMP_Text style, float size, TextAlignmentOptions align)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			CopyFont(style, (TMP_Text)(object)val2);
			((TMP_Text)val2).fontSize = size;
			((TMP_Text)val2).alignment = align;
			((Graphic)val2).raycastTarget = false;
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).richText = true;
			return val2;
		}
	}
}
namespace VSM.Core.Runtime
{
	internal static class Headless
	{
		private static bool? s_isHeadless;

		public static bool IsHeadless
		{
			get
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				if (!s_isHeadless.HasValue)
				{
					s_isHeadless = (int)SystemInfo.graphicsDeviceType == 4 || Application.isBatchMode;
				}
				return s_isHeadless.Value;
			}
		}

		public static bool IsServerProcess => (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer();

		public static bool IsDedicatedServer => (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && ZNet.instance.IsDedicated();

		public static bool IsListenHost => (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && !ZNet.instance.IsDedicated();

		public static bool IsRemoteClient => (Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer();
	}
	internal static class Keys
	{
		public static bool Pressed(KeyboardShortcut shortcut)
		{
			//IL_0003: 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)
			//IL_0009: 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)
			KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
			return (int)mainKey != 0 && ZInput.GetKeyDown(mainKey, false) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((KeyCode m) => ZInput.GetKey(m, false));
		}
	}
}
namespace VSM.Core.Reflection
{
	internal static class GameConstants
	{
		private static uint? s_networkVersion;

		private static long? s_routedEverybody;

		public static uint NetworkVersion
		{
			get
			{
				if (!s_networkVersion.HasValue)
				{
					s_networkVersion = ReadConstant<uint>(typeof(Version), new string[2] { "c_networkVersion", "m_networkVersion" });
				}
				return s_networkVersion.Value;
			}
		}

		public static long RoutedRpcEverybody
		{
			get
			{
				if (!s_routedEverybody.HasValue)
				{
					s_routedEverybody = ReadConstant<long>(typeof(ZRoutedRpc), new string[1] { "Everybody" });
				}
				return s_routedEverybody.Value;
			}
		}

		public static string GameVersionString
		{
			get
			{
				//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)
				try
				{
					return ((object)Version.CurrentVersion/*cast due to .constrained prefix*/).ToString();
				}
				catch (Exception)
				{
					return "?";
				}
			}
		}

		private static T ReadConstant<T>(Type type, params string[] names) where T : struct
		{
			foreach (string name in names)
			{
				FieldInfo field = type.GetField(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(field == null))
				{
					object obj = (field.IsLiteral ? field.GetRawConstantValue() : field.GetValue(null));
					if (obj is T result)
					{
						return result;
					}
					try
					{
						return (T)Convert.ChangeType(obj, typeof(T));
					}
					catch (Exception)
					{
					}
				}
			}
			return default(T);
		}
	}
}
namespace VSM.Core.Net
{
	internal static class ZPackageExt
	{
		public static bool HasMore(this ZPackage pkg)
		{
			return pkg != null && pkg.GetPos() < pkg.Size();
		}

		public static int ReadIntOr(this ZPackage pkg, int fallback)
		{
			return pkg.HasMore() ? pkg.ReadInt() : fallback;
		}

		public static string ReadStringOr(this ZPackage pkg, string fallback)
		{
			return pkg.HasMore() ? pkg.ReadString() : fallback;
		}

		public static bool ReadBoolOr(this ZPackage pkg, bool fallback)
		{
			return pkg.HasMore() ? pkg.ReadBool() : fallback;
		}

		public static string ReadBoundedString(this ZPackage pkg, int maxLength)
		{
			string text = pkg.ReadString();
			return (text != null && text.Length <= maxLength) ? text : null;
		}
	}
}
namespace VSM.Core.Localization
{
	internal static class VsmLocalization
	{
		public static void Register(ManualLogSource log, string pluginDirectory, IDictionary<string, string> embeddedSpanish)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			if (embeddedSpanish != null)
			{
				foreach (KeyValuePair<string, string> item in embeddedSpanish)
				{
					dictionary[item.Key] = item.Value;
				}
			}
			string path = Path.Combine(pluginDirectory ?? string.Empty, "Translations");
			MergeFile(log, Path.Combine(path, "Spanish.json"), dictionary);
			string text = SafeSelectedLanguage();
			if (!string.Equals(text, "Spanish", StringComparison.OrdinalIgnoreCase))
			{
				MergeFile(log, Path.Combine(path, text + ".json"), dictionary);
			}
			Apply(log, dictionary);
		}

		public static string Localize(string token, params object[] args)
		{
			string text = token;
			try
			{
				if (Localization.instance != null && !string.IsNullOrEmpty(token))
				{
					bool flag = token[0] != '$' && token.IndexOf(' ') < 0 && token.IndexOf('\n') < 0;
					string text2 = Localization.instance.Localize(flag ? ("$" + token) : token);
					text = ((flag && text2.Length > 1 && text2[0] == '[' && text2[text2.Length - 1] == ']') ? token : text2);
				}
			}
			catch (Exception)
			{
				text = token;
			}
			if (args != null && args.Length != 0)
			{
				try
				{
					text = string.Format(text, args);
				}
				catch (FormatException)
				{
				}
			}
			return text;
		}

		private static string SafeSelectedLanguage()
		{
			try
			{
				return (Localization.instance != null) ? Localization.instance.GetSelectedLanguage() : "Spanish";
			}
			catch (Exception)
			{
				return "Spanish";
			}
		}

		private static void Apply(ManualLogSource log, Dictionary<string, string> words)
		{
			if (Localization.instance == null)
			{
				if (log != null)
				{
					log.LogWarning((object)"Localization.instance aún no existe; las traducciones no se han aplicado.");
				}
				return;
			}
			foreach (KeyValuePair<string, string> word in words)
			{
				string text = (word.Key.StartsWith("$", StringComparison.Ordinal) ? word.Key.Substring(1) : word.Key);
				Localization.instance.AddWord(text, word.Value);
			}
		}

		private static void MergeFile(ManualLogSource log, string path, Dictionary<string, string> into)
		{
			if (!File.Exists(path))
			{
				return;
			}
			try
			{
				foreach (KeyValuePair<string, string> item in ParseFlatJson(File.ReadAllText(path, Encoding.UTF8)))
				{
					into[item.Key] = item.Value;
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("No se pudo leer " + path + ": " + ex.Message));
				}
			}
		}

		public static Dictionary<string, string> ParseFlatJson(string json)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			if (string.IsNullOrEmpty(json))
			{
				return dictionary;
			}
			int i = 0;
			SkipWs(json, ref i);
			if (i >= json.Length || json[i] != '{')
			{
				return dictionary;
			}
			i++;
			while (true)
			{
				SkipWs(json, ref i);
				if (i >= json.Length || json[i] == '}')
				{
					break;
				}
				if (json[i] == ',')
				{
					i++;
					continue;
				}
				string text = ReadString(json, ref i);
				if (text == null)
				{
					i++;
					continue;
				}
				SkipWs(json, ref i);
				if (i < json.Length && json[i] == ':')
				{
					i++;
				}
				SkipWs(json, ref i);
				if (i < json.Length && json[i] == '"')
				{
					string text2 = ReadString(json, ref i);
					dictionary[text] = text2 ?? string.Empty;
				}
				else
				{
					for (; i < json.Length && json[i] != ',' && json[i] != '}'; i++)
					{
					}
				}
			}
			return dictionary;
		}

		private static void SkipWs(string s, ref int i)
		{
			while (i < s.Length && char.IsWhiteSpace(s[i]))
			{
				i++;
			}
		}

		private static string ReadString(string s, ref int i)
		{
			if (i >= s.Length || s[i] != '"')
			{
				return null;
			}
			i++;
			StringBuilder stringBuilder = new StringBuilder();
			while (i < s.Length)
			{
				char c = s[i++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				case '\\':
				{
					if (i >= s.Length)
					{
						break;
					}
					char c2 = s[i++];
					switch (c2)
					{
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 'b':
						stringBuilder.Append('\b');
						break;
					case 'f':
						stringBuilder.Append('\f');
						break;
					case 'u':
						if (i + 4 <= s.Length)
						{
							stringBuilder.Append((char)Convert.ToInt32(s.Substring(i, 4), 16));
							i += 4;
						}
						break;
					default:
						stringBuilder.Append(c2);
						break;
					}
					continue;
				}
				}
				stringBuilder.Append(c);
			}
			return stringBuilder.ToString();
		}
	}
}
namespace VSM.Core.Harmony
{
	internal static class PatchUtil
	{
		private static readonly List<string> s_failed = new List<string>();

		public static IReadOnlyList<string> FailedTargets => s_failed;

		public static bool IsDegraded => s_failed.Count > 0;

		public static MethodInfo DeclaredMethodOrNull(ManualLogSource log, Type type, string name, Type[] parameters, string owner)
		{
			if (type == null)
			{
				Fail(log, owner, name + " (tipo nulo)");
				return null;
			}
			MethodInfo methodInfo = AccessTools.DeclaredMethod(type, name, parameters, (Type[])null);
			if (methodInfo == null)
			{
				Fail(log, owner, type.FullName + "." + name + "(" + Describe(parameters) + ")");
			}
			return methodInfo;
		}

		public static void PatchAllSafely(ManualLogSource log, Harmony harmony, Assembly assembly)
		{
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(assembly);
			foreach (Type type in typesFromAssembly)
			{
				if (type.GetCustomAttributes(typeof(HarmonyPatch), inherit: true).Length != 0)
				{
					PatchClassSafely(log, harmony, type);
				}
			}
		}

		public static bool PatchClassSafely(ManualLogSource log, Harmony harmony, Type patchClass)
		{
			try
			{
				harmony.CreateClassProcessor(patchClass).Patch();
				return true;
			}
			catch (Exception ex)
			{
				Fail(log, harmony.Id, patchClass.FullName + " -> " + ex.GetType().Name + ": " + ex.Message);
				return false;
			}
		}

		private static void Fail(ManualLogSource log, string owner, string what)
		{
			s_failed.Add(what);
			if (log != null)
			{
				log.LogError((object)("[" + owner + "] No se pudo aplicar el parche (¿cambió el juego?): " + what + ". El mod sigue cargado en modo degradado."));
			}
		}

		private static string Describe(Type[] parameters)
		{
			if (parameters == null || parameters.Length == 0)
			{
				return string.Empty;
			}
			string[] array = new string[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				array[i] = ((parameters[i] == null) ? "?" : parameters[i].Name);
			}
			return string.Join(", ", array);
		}
	}
}
namespace VSM.Core.Config
{
	internal sealed class ConfigurationManagerAttributes
	{
		public bool? ShowRangeAsPercent;

		public Action<ConfigEntryBase> CustomDrawer;

		public bool? Browsable;

		public string Category;

		public object DefaultValue;

		public bool? HideDefaultButton;

		public bool? HideSettingName;

		public string Description;

		public string DispName;

		public int? Order;

		public bool? ReadOnly;

		public bool? IsAdvanced;

		public bool? IsAdminOnly;

		public Func<object, string> ObjToStr;

		public Func<string, object> StrToObj;
	}
}
namespace VSM.Core.Camera
{
	internal struct RigSettings
	{
		public float Speed;

		public float FastMultiplier;

		public bool MoveRelativeToView;
	}
	internal sealed class CameraRig
	{
		public const float MaxPitch = 89f;

		public float Yaw;

		public float Pitch;

		public Vector3 Position;

		public Vector3 Velocity;

		public Vector3 ForwardVector => Forward(Yaw, Pitch);

		public Quaternion Rotation => Quaternion.Euler(Pitch, Yaw, 0f);

		public static Vector3 Forward(float yawDeg, float pitchDeg)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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)
			float num = yawDeg * ((float)Math.PI / 180f);
			float num2 = pitchDeg * ((float)Math.PI / 180f);
			float num3 = Mathf.Cos(num2);
			return new Vector3(Mathf.Sin(num) * num3, 0f - Mathf.Sin(num2), Mathf.Cos(num) * num3);
		}

		public static Vector3 FlatForward(float yawDeg)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			float num = yawDeg * ((float)Math.PI / 180f);
			return new Vector3(Mathf.Sin(num), 0f, Mathf.Cos(num));
		}

		public static Vector3 Right(float yawDeg)
		{
			//IL_001b: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			float num = yawDeg * ((float)Math.PI / 180f);
			return new Vector3(Mathf.Cos(num), 0f, 0f - Mathf.Sin(num));
		}

		public void Reset(Vector3 position, Vector3 forward)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Position = position;
			Velocity = Vector3.zero;
			SetFromDirection(forward);
		}

		public void SetFromDirection(Vector3 forward)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (((Vector3)(ref forward)).sqrMagnitude < 1E-08f)
			{
				Yaw = 0f;
				Pitch = 0f;
			}
			else
			{
				((Vector3)(ref forward)).Normalize();
				Yaw = Mathf.Repeat(Mathf.Atan2(forward.x, forward.z) * 57.29578f, 360f);
				Pitch = Mathf.Clamp((0f - Mathf.Asin(Mathf.Clamp(forward.y, -1f, 1f))) * 57.29578f, -89f, 89f);
			}
		}

		public void ApplyLook(Vector2 delta)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Yaw = Mathf.Repeat(Yaw + delta.x, 360f);
			Pitch = Mathf.Clamp(Pitch - delta.y, -89f, 89f);
		}

		public Vector3 DesiredVelocity(Vector3 move, float vertical, bool fast, RigSettings settings)
		{
			//IL_0023: 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)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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)
			//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_0064: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (settings.MoveRelativeToView ? Forward(Yaw, Pitch) : FlatForward(Yaw));
			Vector3 val2 = Right(Yaw) * Mathf.Clamp(move.x, -1f, 1f) + val * Mathf.Clamp(move.z, -1f, 1f) + Vector3.up * Mathf.Clamp(vertical, -1f, 1f);
			if (((Vector3)(ref val2)).sqrMagnitude > 1f)
			{
				((Vector3)(ref val2)).Normalize();
			}
			float num = Mathf.Max(0f, settings.Speed) * (fast ? Mathf.Max(1f, settings.FastMultiplier) : 1f);
			return val2 * num;
		}

		public void Integrate(Vector3 desiredVelocity, float dt, float smoothing)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0053: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			if (!(dt <= 0f))
			{
				float num = ((smoothing <= 0f) ? 1f : (1f - Mathf.Exp((0f - dt) / smoothing)));
				Velocity = Vector3.Lerp(Velocity, desiredVelocity, num);
				Position += Velocity * dt;
			}
		}

		public static Vector3 ClampToSphere(Vector3 pos, Vector3 center, float radius)
		{
			//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)
			//IL_0003: 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)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = pos - center;
			float num = Mathf.Max(0f, radius);
			if (((Vector3)(ref val)).sqrMagnitude <= num * num)
			{
				return pos;
			}
			return center + ((Vector3)(ref val)).normalized * num;
		}
	}
	internal static class CameraWorld
	{
		public const float CollisionRadius = 0.25f;

		public static Vector3 Anchor(Player player)
		{
			//IL_0033: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Transform eye = ((Character)player).m_eye;
			return ((Object)(object)eye != (Object)null) ? eye.position : (((Component)player).transform.position + Vector3.up * 1.6f);
		}

		public static Vector3 Constrain(Vector3 from, Vector3 to, Vector3 anchor, float maxDistance, float clearance, GameCamera cam)
		{
			//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)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			Vector3 pos = CameraRig.ClampToSphere(to, anchor, maxDistance);
			pos = Lift(pos, clearance, cam);
			pos = CameraRig.ClampToSphere(pos, anchor, maxDistance + 1f);
			LayerMask blockCameraMask = cam.m_blockCameraMask;
			Vector3 val = (Overlaps(from, blockCameraMask) ? anchor : from);
			return Collide(val, pos, blockCameraMask);
		}

		public static Vector3 Lift(Vector3 pos, float clearance, GameCamera cam)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_00af: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			clearance = Mathf.Max(0f, clearance);
			ZoneSystem instance = ZoneSystem.instance;
			float num = default(float);
			if ((Object)(object)instance != (Object)null && instance.GetGroundHeight(pos, ref num))
			{
				pos.y = Mathf.Max(pos.y, num + clearance);
			}
			float num2 = Floating.GetLiquidLevel(pos, 1f, (LiquidType)10);
			if ((Object)(object)instance != (Object)null && !Character.InInterior(pos))
			{
				num2 = Mathf.Max(num2, instance.m_waterLevel);
			}
			if (num2 > -9000f)
			{
				pos.y = Mathf.Max(pos.y, num2 + Mathf.Max(clearance, cam.m_minWaterDistance));
			}
			return pos;
		}

		public static bool Overlaps(Vector3 pos, LayerMask mask)
		{
			//IL_0001: 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)
			return Physics.CheckSphere(pos, 0.225f, LayerMask.op_Implicit(mask), (QueryTriggerInteraction)1);
		}

		public static Vector3 Collide(Vector3 from, Vector3 to, LayerMask mask)
		{
			//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)
			//IL_0003: 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)
			//IL_0025: 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_002c: 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_0033: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = to - from;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 1E-05f)
			{
				return to;
			}
			Vector3 val2 = val / magnitude;
			RaycastHit val3 = default(RaycastHit);
			if (Physics.SphereCast(from, 0.25f, val2, ref val3, magnitude, LayerMask.op_Implicit(mask), (QueryTriggerInteraction)1))
			{
				return from + val2 * Mathf.Max(0f, ((RaycastHit)(ref val3)).distance - 0.02f);
			}
			return to;
		}
	}
	internal static class CameraLock
	{
		private const string Prefix = "vsm_camera_lock:";

		public static string Holder()
		{
			GameCamera instance = GameCamera.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			Transform transform = ((Component)instance).transform;
			for (int i = 0; i < transform.childCount; i++)
			{
				string name = ((Object)transform.GetChild(i)).name;
				if (name.StartsWith("vsm_camera_lock:", StringComparison.Ordinal))
				{
					return name.Substring("vsm_camera_lock:".Length);
				}
			}
			return null;
		}

		public static bool TryAcquire(string owner)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			GameCamera instance = GameCamera.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			string text = Holder();
			if (text != null)
			{
				return text == owner;
			}
			GameObject val = new GameObject("vsm_camera_lock:" + owner);
			val.transform.SetParent(((Component)instance).transform, false);
			return true;
		}

		public static void Release(string owner)
		{
			GameCamera instance = GameCamera.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)instance).transform;
			for (int num = transform.childCount - 1; num >= 0; num--)
			{
				Transform child = transform.GetChild(num);
				if (((Object)child).name == "vsm_camera_lock:" + owner)
				{
					Object.Destroy((Object)(object)((Component)child).gameObject);
					((Object)child).name = "vsm_camera_lock_released";
				}
			}
		}
	}
	internal sealed class BodyHider
	{
		private readonly List<Renderer> _hidden = new List<Renderer>();

		private float _nextScan;

		public void Update(Player player, bool hide)
		{
			if (!hide || (Object)(object)player == (Object)null)
			{
				Restore();
			}
			else
			{
				if (Time.unscaledTime < _nextScan)
				{
					return;
				}
				_nextScan = Time.unscaledTime + 0.5f;
				Renderer[] componentsInChildren = ((Component)player).GetComponentsInChildren<Renderer>(false);
				foreach (Renderer val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null && val.enabled && (val is SkinnedMeshRenderer || val is MeshRenderer))
					{
						val.enabled = false;
						_hidden.Add(val);
					}
				}
			}
		}

		public void Restore()
		{
			foreach (Renderer item in _hidden)
			{
				if ((Object)(object)item != (Object)null)
				{
					item.enabled = true;
				}
			}
			_hidden.Clear();
			_nextScan = 0f;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}