using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using DynamicLocations.API;
using DynamicLocations.Commands;
using DynamicLocations.Config;
using DynamicLocations.Constants;
using DynamicLocations.Controllers;
using DynamicLocations.Patches;
using DynamicLocations.Structs;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using ZdoWatcher;
using Zolantris.Shared.Debug;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("DynamicLocations")]
[assembly: AssemblyDescription("Valheim Mod made to attach to an item/prefab such as a bed and place a player or object near the item wherever it is in the current game. Meant for ValheimVehicles but could be used for any movement mod. Requires Jotunn and ZdoWatcher")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Virtualize LLC")]
[assembly: AssemblyProduct("DynamicLocations")]
[assembly: AssemblyCopyright("Copyright © 2023-2024, GNU-v3 licensed")]
[assembly: Guid("6015B165-2627-40A7-8CA1-3E6B6CD7CB49")]
[assembly: AssemblyFileVersion("1.2.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DynamicLocations
{
	internal class ZdoWatcherDelegate
	{
		public static readonly int DynamicLocationSpawn = StringExtensionMethods.GetStableHashCode("DynamicLocation_Spawn");

		public static readonly int DynamicLocationLogout = StringExtensionMethods.GetStableHashCode("DynamicLocation_Logout");

		public static Dictionary<int, ZDOID> DynamicSpawns;

		public void RegisterToZdoManager()
		{
			ZdoWatchController.OnDeserialize = (Action<ZDO>)Delegate.Combine(ZdoWatchController.OnDeserialize, new Action<ZDO>(OnZdoRegister));
			ZdoWatchController.OnLoad = (Action<ZDO>)Delegate.Combine(ZdoWatchController.OnLoad, new Action<ZDO>(OnZdoRegister));
		}

		private static void OnZdoRegister(ZDO zdo)
		{
		}

		public static void OnZdoUnRegister(ZDO zdo)
		{
		}
	}
	[BepInPlugin("zolantris.DynamicLocations", "DynamicLocations", "1.2.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class DynamicLocationsPlugin : BaseUnityPlugin
	{
		public const string Author = "zolantris";

		public const string Version = "1.2.0";

		public const string ModName = "DynamicLocations";

		public const string BepInGuid = "zolantris.DynamicLocations";

		private static Harmony _harmony;

		public const string ModDescription = "Valheim Mod made to attach to an item/prefab such as a bed and place a player or object near the item wherever it is in the current game. Meant for ValheimVehicles but could be used for any movement mod. Requires Jotunn and ZdoWatcher";

		public const string CopyRight = "Copyright © 2023-2024, GNU-v3 licensed";

		public static string HarmonyGuid => "zolantris.DynamicLocations";

		public void Awake()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			DynamicLocationsConfig.BindConfig(((BaseUnityPlugin)this).Config);
			_harmony = new Harmony(HarmonyGuid);
			_harmony.PatchAll(typeof(DynamicLocationsPatches));
			RegisterCommands();
		}

		public void RegisterCommands()
		{
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new DynamicLocationsCommands());
		}
	}
}
namespace DynamicLocations.Structs
{
	public struct DynamicLocation
	{
		public Tuple<int, int> zoneId;

		public Tuple<float, float, float> position;

		public LocationVariation locationType;
	}
	public struct IntegrationConfig
	{
		public string ZdoTargetTargetPrefabName { get; private set; }

		public string Guid { get; set; }

		public string Version { get; set; }

		public string Name { get; set; }

		public BaseUnityPlugin Plugin { get; set; }

		public bool UseDefaultCallbacks { get; set; }

		public int MovementTimeout { get; set; }

		public bool ShouldFreezePlayer { get; set; }

		public int LoginPrefabHashCode { get; set; }

		public int Priority { get; set; }

		public List<string> RunBeforePlugins { get; }

		public List<string> RunAfterPlugins { get; }

		[UsedImplicitly]
		public IntegrationConfig()
		{
			UseDefaultCallbacks = false;
			MovementTimeout = 0;
			ShouldFreezePlayer = false;
			LoginPrefabHashCode = 0;
			Priority = 999;
			RunBeforePlugins = new List<string>();
			RunAfterPlugins = new List<string>();
			throw new Exception("This constructor is not supported, please provide plugin and zdoTargetPrefabName");
		}

		public IntegrationConfig(BaseUnityPlugin plugin, string zdoTargetPrefabName)
		{
			UseDefaultCallbacks = false;
			MovementTimeout = 0;
			ShouldFreezePlayer = false;
			LoginPrefabHashCode = 0;
			Priority = 999;
			RunBeforePlugins = new List<string>();
			RunAfterPlugins = new List<string>();
			Plugin = plugin;
			ZdoTargetTargetPrefabName = zdoTargetPrefabName;
			LoginPrefabHashCode = zdoTargetPrefabName.GetHashCode();
			Name = plugin.Info.Metadata.Name;
			Version = plugin.Info.Metadata.Version.ToString();
			Guid = plugin.Info.Metadata.GUID;
			Logger.LogDebug((object)$"PluginVersion: {plugin.Info.Metadata.Version} stringVersion {Version}, Name: {Name}");
		}
	}
}
namespace DynamicLocations.Prefabs
{
	public class DynamicPointPrefab
	{
		public static readonly DynamicPointPrefab Instance = new DynamicPointPrefab();

		public void Register(PrefabManager prefabManager, PieceManager pieceManager)
		{
			prefabManager.CreateEmptyPrefab("DynamicLocations_Prefabs_SpawnPoint", true).layer = LayerMask.NameToLayer("piece");
		}
	}
	public static class PrefabNames
	{
		private const string ModNamePrefix = "DynamicLocations_Prefabs";

		public const string SpawnPoint = "DynamicLocations_Prefabs_SpawnPoint";
	}
}
namespace DynamicLocations.Patches
{
	public class DynamicLocationsPatches
	{
		[HarmonyPatch(typeof(Bed), "Interact")]
		[HarmonyPostfix]
		private static void OnSpawnPointUpdated(Bed __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Game.instance.GetPlayerProfile().GetCustomSpawnPoint();
			if (((Character)Player.m_localPlayer).InInterior())
			{
				if (DynamicLocationsConfig.IsDebug)
				{
					Logger.LogDebug((object)"Cannot dynamic spawn inside dungeon or building. InIniterior returned true, must skip.");
				}
				return;
			}
			PlayerSpawnController instance = PlayerSpawnController.Instance;
			if (Object.op_Implicit((Object)(object)instance))
			{
				instance?.SyncBedSpawnPoint(__instance.m_nview.GetZDO(), __instance);
			}
		}

		[HarmonyPatch(typeof(Player), "OnDeath")]
		[HarmonyPostfix]
		private static void OnDeathDestroyLogoutPoint(Player __instance)
		{
			if (((Character)__instance).m_nview.IsOwner())
			{
				LocationController.RemoveZdoTarget(LocationVariation.Logout, __instance);
			}
		}

		[HarmonyPatch(typeof(Player), "ShowTeleportAnimation")]
		[HarmonyPostfix]
		private static void ShowTeleportAnimation(bool __result)
		{
			PlayerSpawnController? instance = PlayerSpawnController.Instance;
			if (instance != null && instance.IsTeleportingToDynamicLocation)
			{
				__result = false;
			}
		}

		[HarmonyPatch(typeof(Game), "Awake")]
		[HarmonyPostfix]
		private static void AddSpawnController(Game __instance)
		{
			Logger.LogDebug((object)"Game Awake called and added PlayerSpawnController and LocationController");
			((Component)__instance).gameObject.AddComponent<LocationController>();
			((Component)__instance).gameObject.AddComponent<PlayerSpawnController>();
		}

		[HarmonyPatch(typeof(Game), "OnDestroy")]
		[HarmonyPostfix]
		private static void ResetSpawnController(Game __instance)
		{
			Logger.LogDebug((object)"Game destroy called ResetSpawnController");
			LocationController.ResetCachedValues();
		}

		[HarmonyPatch(typeof(Game), "SpawnPlayer")]
		[HarmonyPostfix]
		private static void OnSpawned(Game __instance, Player __result)
		{
			if (!ZNetView.m_forceDisableInit)
			{
				if (__instance.m_respawnAfterDeath && DynamicLocationsConfig.EnableDynamicSpawnPoint.Value && !((Character)__result).InIntro())
				{
					PlayerSpawnController.Instance?.MovePlayerToSpawnPoint();
				}
				else if (DynamicLocationsConfig.EnableDynamicLogoutPoint.Value && !((Character)__result).InInterior() && !((Character)__result).InIntro())
				{
					PlayerSpawnController.Instance?.MovePlayerToLogoutPoint();
				}
			}
		}
	}
}
namespace DynamicLocations.Interfaces
{
	internal interface IModLoginAPI
	{
		BaseUnityPlugin Plugin { get; set; }

		bool UseDefaultCallbacks { get; }

		int MovementTimeout { get; }

		bool ShouldFreezePlayer { get; }

		int LoginPrefabHashCode { get; }

		int Priority { get; }

		List<string> RunBeforePlugins { get; }

		List<string> RunAfterPlugins { get; }

		IEnumerator OnLoginMoveToZDO(ZDO zdo, Vector3? offset, PlayerSpawnController playerSpawnController);

		bool OnLoginMatchZdoPrefab(ZDO zdo);
	}
	public interface IVehiclePiecesController
	{
		bool IsActivationComplete { get; }
	}
}
namespace DynamicLocations.Controllers
{
	public interface ICachedLocation
	{
		Vector3? Offset { get; set; }

		ZDO Zdo { get; set; }
	}
	public class CacheLocationItem : ICachedLocation
	{
		public Vector3? Offset { get; set; }

		public ZDO Zdo { get; set; }
	}
	public class LocationController : MonoBehaviour
	{
		private const string DynamicPrefix = "Dynamic";

		private const string SpawnZdoPrefix = "SpawnZdo";

		private const string SpawnZdoOffsetPrefix = "SpawnZdoOffset";

		private const string LogoutParentZdoOffsetPrefix = "LogoutParentZdoOffset";

		private const string LogoutParentZdoPrefix = "LogoutParentZdo";

		private static Dictionary<LocationVariation, ICachedLocation> _cachedLocations = new Dictionary<LocationVariation, ICachedLocation>();

		public static LocationController Instance;

		internal static long WorldIdOverride = 0L;

		private static long CurrentWorldId
		{
			get
			{
				if (WorldIdOverride == 0L)
				{
					ZNet instance = ZNet.instance;
					if (instance == null)
					{
						return 0L;
					}
					return instance.GetWorldUID();
				}
				return WorldIdOverride;
			}
		}

		public void Awake()
		{
			Instance = this;
		}

		public void OnDestroy()
		{
			_cachedLocations.Clear();
		}

		public static ICachedLocation? GetCachedDynamicLocation(LocationVariation locationVariationType)
		{
			_cachedLocations.TryGetValue(locationVariationType, out ICachedLocation value);
			return value;
		}

		public static bool SetCachedDynamicLocation(LocationVariation locationVariationType, CacheLocationItem cachedLocationItem)
		{
			if (GetCachedDynamicLocation(locationVariationType) != null)
			{
				_cachedLocations[locationVariationType] = cachedLocationItem;
			}
			else
			{
				_cachedLocations.Add(locationVariationType, cachedLocationItem);
			}
			return true;
		}

		public static string GetPluginPrefix()
		{
			return "DynamicLocations";
		}

		public static string GetFullPrefix()
		{
			return GetPluginPrefix() + "_Dynamic";
		}

		public static string GetLogoutZdoOffsetKey()
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return string.Format("{0}_{1}_{2}", GetFullPrefix(), "LogoutParentZdoOffset", CurrentWorldId);
			}
			return "";
		}

		public static string GetLogoutZdoKey()
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return string.Format("{0}_{1}_{2}", GetFullPrefix(), "LogoutParentZdo", CurrentWorldId);
			}
			return "";
		}

		public static string GetSpawnZdoOffsetKey()
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return string.Format("{0}_{1}_{2}", GetFullPrefix(), "SpawnZdoOffset", CurrentWorldId);
			}
			return "";
		}

		public static string GetSpawnZdoKey()
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return string.Format("{0}_{1}_{2}", GetFullPrefix(), "SpawnZdo", CurrentWorldId);
			}
			return "";
		}

		private static string ZDOIDToString(ZDOID zdoid)
		{
			long userID = ((ZDOID)(ref zdoid)).UserID;
			uint iD = ((ZDOID)(ref zdoid)).ID;
			return $"{userID},{iD}";
		}

		private static ZDOID? StringToZDOID(string zdoidString)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			string[] array = zdoidString.Split(new char[1] { ',' });
			if (array.Length != 2)
			{
				return null;
			}
			long.TryParse(array[0], out var result);
			uint.TryParse(array[1], out var result2);
			if (result == 0L || result2 == 0)
			{
				Logger.LogDebug((object)"failed to parse to ZDOID");
				return null;
			}
			return new ZDOID(result, result2);
		}

		private static string Vector3ToString(Vector3 val)
		{
			//IL_0005: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"{val.x},{val.y},{val.z}";
		}

		private static Vector3? StringToVector3(string val)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			string[] array = val.Split(new char[1] { ',' });
			if (array.Length != 3)
			{
				return null;
			}
			float.TryParse(array[0], out var result);
			float.TryParse(array[1], out var result2);
			float.TryParse(array[2], out var result3);
			return new Vector3(result, result2, result3);
		}

		internal static void DEBUG_RemoveAllDynamicLocationKeys()
		{
			KeyValuePair<string, string>[] array = Player.m_localPlayer.m_customData.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<string, string> keyValuePair = array[i];
				if (keyValuePair.Key.Contains(GetFullPrefix()))
				{
					Logger.LogDebug((object)("Removing: Key: " + keyValuePair.Key + " Value: " + keyValuePair.Value));
					Player.m_localPlayer.m_customData.Remove(keyValuePair.Key);
				}
			}
		}

		internal static void DEBUGCOMMAND_RemoveLogout()
		{
			string logoutZdoKey = GetLogoutZdoKey();
			Logger.LogInfo((object)(Player.m_localPlayer.m_customData.Remove(logoutZdoKey) ? ("Removing logout key: " + logoutZdoKey) : "No logout key found"));
		}

		internal static void DEBUGCOMMAND_ListAllKeys()
		{
			KeyValuePair<string, string>[] array = Player.m_localPlayer.m_customData.ToArray();
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			List<string> list4 = new List<string>();
			string[] value = Player.m_localPlayer.m_customData.ToArray().Where(delegate(KeyValuePair<string, string> keyValuePair)
			{
				KeyValuePair<string, string> keyValuePair4 = keyValuePair;
				return keyValuePair4.Key.Contains($"{CurrentWorldId}");
			}).Select(delegate(KeyValuePair<string, string> keyValuePair)
			{
				KeyValuePair<string, string> keyValuePair3 = keyValuePair;
				return keyValuePair3.Value;
			})
				.ToArray();
			KeyValuePair<string, string>[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				KeyValuePair<string, string> keyValuePair2 = array2[i];
				if (keyValuePair2.Key.Contains(GetFullPrefix()))
				{
					if (keyValuePair2.Key.Contains("SpawnZdoOffset"))
					{
						list4.Add(keyValuePair2.Value);
					}
					else if (keyValuePair2.Key.Contains("SpawnZdo"))
					{
						list3.Add(keyValuePair2.Value);
					}
					else if (keyValuePair2.Key.Contains("LogoutParentZdoOffset"))
					{
						list2.Add(keyValuePair2.Value);
					}
					else if (keyValuePair2.Key.Contains("LogoutParentZdo"))
					{
						list.Add(keyValuePair2.Value);
					}
				}
			}
			Logger.LogInfo((object)("currentWorldItems: " + string.Join(", ", value)));
			Logger.LogInfo((object)("spawnKeys: " + string.Join(", ", list3)));
			Logger.LogInfo((object)("spawnOffsetKeys: " + string.Join(", ", list4)));
			Logger.LogInfo((object)("logoutKeys: " + string.Join(", ", list)));
			Logger.LogInfo((object)("logoutOffsetKeys: " + string.Join(", ", list2)));
		}

		public static bool RemoveZdoTarget(LocationVariation locationVariationType, Player? player)
		{
			RemoveTargetKey(locationVariationType, player);
			return true;
		}

		public static int? GetZdoFromStore(LocationVariation locationVariationType, Player? player)
		{
			string zdoStorageKey = GetZdoStorageKey(locationVariationType);
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			if (!player.m_customData.TryGetValue(zdoStorageKey, out var value))
			{
				return null;
			}
			if (!int.TryParse(value, out var result))
			{
				Logger.LogError((object)("The targetKey <" + zdoStorageKey + "> zdoKey: <" + value + "> could not be parsed as an int"));
				return null;
			}
			Logger.LogDebug((object)$"Retreiving targetKey <{zdoStorageKey}> zdoKey: <{value}> for name: {player.GetPlayerName()} id: {player.GetPlayerID()}");
			return result;
		}

		public static bool TryGetWorldUidFromKey(string storageKey, out long worldUid)
		{
			long.TryParse(storageKey.Split(new char[1] { '_' }).Last(), out var result);
			worldUid = result;
			return result == CurrentWorldId;
		}

		public static void RemoveTargetKey(LocationVariation locationVariationType, Player? player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)ZNet.instance == (Object)null))
			{
				string zdoStorageKey = GetZdoStorageKey(locationVariationType);
				string offsetStorageKey = GetOffsetStorageKey(locationVariationType);
				if (!TryGetWorldUidFromKey(zdoStorageKey, out var worldUid))
				{
					Logger.LogWarning((object)$"Skipping key deletion due to current world {CurrentWorldId} not matching key worldUid {worldUid}");
					return;
				}
				player.m_customData.Remove(zdoStorageKey);
				player.m_customData.Remove(offsetStorageKey);
				Game.instance.m_playerProfile.SavePlayerData(player);
			}
		}

		public static IEnumerator GetZdoFromStoreAsync(LocationVariation locationVariationType, Player? player, Action<ZDO?> onComplete)
		{
			int? zdoFromStore = GetZdoFromStore(locationVariationType, player);
			if (!zdoFromStore.HasValue)
			{
				onComplete(null);
				yield break;
			}
			ZDO zdoOutput = null;
			yield return ZdoWatchController.Instance.GetZdoFromServerAsync(zdoFromStore.Value, (Action<ZDO>)delegate(ZDO? output)
			{
				zdoOutput = output;
			});
			if (zdoOutput == null)
			{
				Logger.LogDebug((object)"Removing targetKey as it's ZDO no longer exists");
				RemoveTargetKey(locationVariationType, player);
			}
			else if (zdoOutput.GetInt("DynamicLocations_Point", 0) != 0)
			{
				onComplete(zdoOutput);
			}
		}

		public static void ResetCachedValues()
		{
			_cachedLocations.Clear();
		}

		public static Vector3 GetOffset(LocationVariation locationVariationType, Player? player)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return GetOffset(GetOffsetStorageKey(locationVariationType), player);
		}

		public static Vector3 GetOffset(string key, Player? player)
		{
			//IL_0009: 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_003d: 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)player == (Object)null)
			{
				return Vector3.zero;
			}
			if (!player.m_customData.TryGetValue(key, out var value))
			{
				return Vector3.zero;
			}
			return (Vector3)(((??)StringToVector3(value)) ?? Vector3.zero);
		}

		public static ZDO? SetZdo(LocationVariation locationVaration, Player? player, ZDO? zdo)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return null;
			}
			if (zdo == null)
			{
				return null;
			}
			string zdoStorageKey = GetZdoStorageKey(locationVaration);
			int num = default(int);
			if (!ZdoWatchController.GetPersistentID(zdo, ref num))
			{
				Logger.LogWarning((object)$"No persistent id found for dynamicObj {zdo}");
				return null;
			}
			zdo.Set("DynamicLocations_Point", 1);
			if (player.m_customData.TryGetValue(zdoStorageKey, out var _))
			{
				player.m_customData[zdoStorageKey] = num.ToString();
			}
			else
			{
				player.m_customData.Add(zdoStorageKey, num.ToString());
			}
			if (!player.m_customData.ContainsKey(zdoStorageKey))
			{
				Logger.LogError((object)"Zdo string failed to set on player.customData");
			}
			Logger.LogDebug((object)$"Setting key: {zdoStorageKey}, uid: {zdo.m_uid} for name: {player.GetPlayerName()} id: {player.GetPlayerID()}");
			Game.instance.m_playerProfile.SavePlayerData(player);
			return zdo;
		}

		public static Vector3? SetOffset(LocationVariation locationVariationType, Player player, Vector3 offset)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return SetOffset(GetOffsetStorageKey(locationVariationType), player, offset);
		}

		public static Vector3? SetOffset(string key, Player player, Vector3 offset)
		{
			//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)
			//IL_004d: 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)
			if (!Object.op_Implicit((Object)(object)player))
			{
				return null;
			}
			if (Vector3.zero == offset)
			{
				if (player.m_customData.TryGetValue(key, out var _))
				{
					player.m_customData.Remove(key);
				}
				return null;
			}
			player.m_customData[key] = Vector3ToString(offset);
			return offset;
		}

		public static string GetOffsetStorageKey(LocationVariation locationVariationType)
		{
			return locationVariationType switch
			{
				LocationVariation.Spawn => GetSpawnZdoOffsetKey(), 
				LocationVariation.Logout => GetLogoutZdoOffsetKey(), 
				_ => throw new ArgumentOutOfRangeException("locationVariationType", locationVariationType, null), 
			};
		}

		public static string GetZdoStorageKey(LocationVariation locationVariationType)
		{
			return locationVariationType switch
			{
				LocationVariation.Spawn => GetSpawnZdoKey(), 
				LocationVariation.Logout => GetLogoutZdoKey(), 
				_ => throw new ArgumentOutOfRangeException("locationVariationType", locationVariationType, null), 
			};
		}

		public static bool SetLocationTypeData(LocationVariation locationVariation, Player player, ZDO zdo, Vector3 offset)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Vector3? offset2 = SetOffset(GetOffsetStorageKey(locationVariation), player, offset);
			ZDO val = SetZdo(locationVariation, player, zdo);
			if (val == null)
			{
				return false;
			}
			SetCachedDynamicLocation(locationVariation, new CacheLocationItem
			{
				Zdo = val,
				Offset = offset2
			});
			return true;
		}

		public static void SaveWorldData()
		{
			World.GetWorldSavePath((FileSource)0);
			_ = Game.instance.m_devWorldName + "_mod_dynamic_locations.json";
		}
	}
	public class LoginAPIController
	{
		internal static readonly Dictionary<string, DynamicLoginIntegration> LoginIntegrations = new Dictionary<string, DynamicLoginIntegration>();

		internal static readonly Dictionary<string, DynamicLoginIntegration> DisabledLoginIntegrations = new Dictionary<string, DynamicLoginIntegration>();

		internal static List<DynamicLoginIntegration> loginIntegrationsByPriority = new List<DynamicLoginIntegration>();

		private PlayerSpawnController? _playerSpawnController => PlayerSpawnController.Instance;

		private static string? GetModIntegrationId(DynamicLoginIntegration integration)
		{
			if (integration.Guid != "")
			{
				return integration.Guid;
			}
			Logger.LogWarning((object)"Invalid guid detected, make sure the BepInPlugin guid is a valid number");
			return null;
		}

		public static List<DynamicLoginIntegration> OrderItems(List<DynamicLoginIntegration> items)
		{
			Dictionary<string, DynamicLoginIntegration> itemLookup = items.ToDictionary((DynamicLoginIntegration i) => i.Guid);
			List<DynamicLoginIntegration> result = new List<DynamicLoginIntegration>();
			HashSet<string> placed = new HashSet<string>();
			foreach (DynamicLoginIntegration item in items.OrderBy((DynamicLoginIntegration i) => i.Guid))
			{
				AddItemWithDependencies(item, itemLookup, result, placed);
			}
			return result;
		}

		private static void AddItemWithDependencies(DynamicLoginIntegration item, Dictionary<string, DynamicLoginIntegration> itemLookup, List<DynamicLoginIntegration> result, HashSet<string> placed)
		{
			if (placed.Contains(item.Guid))
			{
				return;
			}
			foreach (string runAfterPlugin in item.RunAfterPlugins)
			{
				if (itemLookup.TryGetValue(runAfterPlugin, out DynamicLoginIntegration value))
				{
					AddItemWithDependencies(value, itemLookup, result, placed);
				}
			}
			result.Add(item);
			placed.Add(item.Guid);
			foreach (string runBeforePlugin in item.RunBeforePlugins)
			{
				if (itemLookup.TryGetValue(runBeforePlugin, out DynamicLoginIntegration value2))
				{
					AddItemWithDependencies(value2, itemLookup, result, placed);
				}
			}
		}

		internal static void UpdateIntegrations()
		{
			foreach (string disabledLoginApiIntegration in DynamicLocationsConfig.DisabledLoginApiIntegrations)
			{
				if (LoginIntegrations.ContainsKey(disabledLoginApiIntegration))
				{
					LoginIntegrations.Remove(disabledLoginApiIntegration);
				}
			}
			foreach (KeyValuePair<string, DynamicLoginIntegration> disabledLoginIntegration in DisabledLoginIntegrations)
			{
				bool flag = false;
				foreach (string disabledLoginApiIntegration2 in DynamicLocationsConfig.DisabledLoginApiIntegrations)
				{
					if (DisabledLoginIntegrations.ContainsKey(disabledLoginApiIntegration2))
					{
						flag = true;
					}
				}
				if (!flag)
				{
					LoginIntegrations.Add(disabledLoginIntegration.Key, disabledLoginIntegration.Value);
				}
			}
			loginIntegrationsByPriority = OrderItems(LoginIntegrations.Values.ToList());
			foreach (DynamicLoginIntegration item in loginIntegrationsByPriority)
			{
				Logger.LogInfo((object)$"item ----> name:{item.Name}, guid: {item.Guid}, priority: {item.Priority}");
			}
		}

		public static bool AddLoginApiIntegration(DynamicLoginIntegration loginIntegration)
		{
			string modIntegrationId = GetModIntegrationId(loginIntegration);
			if (modIntegrationId == null)
			{
				return false;
			}
			if (!LoginIntegrations.ContainsKey(modIntegrationId))
			{
				LoginIntegrations.Add(modIntegrationId, loginIntegration);
				UpdateIntegrations();
				return true;
			}
			if (loginIntegration.LoginPrefabHashCode == 0)
			{
				Logger.LogWarning((object)$"LoginIntegration provided invalid prefab identifier, the hashcode was {loginIntegration.LoginPrefabHashCode}.");
			}
			if (DynamicLocationsConfig.IsDebug)
			{
				if (!ZNetScene.instance.m_namedPrefabs.TryGetValue(loginIntegration.LoginPrefabHashCode, out var value))
				{
					Logger.LogError((object)$"Prefab not found for stableHashCode {loginIntegration.LoginPrefabHashCode}");
				}
				else
				{
					Logger.LogDebug((object)$"Found prefab for stableHashCode {loginIntegration.LoginPrefabHashCode} name {((Object)value).name}");
				}
			}
			Logger.LogError((object)"Could not integrate component due to collision in registered plugin GUID and plugin_version, this ModAPI plugin will not be loaded. Make sure your plugin only creates 1 instance of ModLoginApi and that your plugin GUID or plugin.Name_plugin_Version are unique.");
			return false;
		}

		private static void LogResults(DynamicLoginIntegration? selectedIntegration)
		{
			if (DynamicLocationsConfig.IsDebug)
			{
				Logger.LogDebug((object)((selectedIntegration != null) ? ("Successfully handled ModApi " + selectedIntegration.Name + " matched") : "No matches found for registered integrations"));
			}
		}

		public static IEnumerator RunAllIntegrations_OnLoginMoveToZdo(ZDO zdo, Vector3? offset, PlayerSpawnController playerSpawnController)
		{
			if ((Object)(object)playerSpawnController == (Object)null)
			{
				yield break;
			}
			DynamicLoginIntegration selectedIntegration = null;
			foreach (DynamicLoginIntegration item in loginIntegrationsByPriority)
			{
				if (item.OnLoginMatchZdoPrefab(zdo))
				{
					selectedIntegration = item;
					yield return item.API_OnLoginMoveToZDO(zdo, offset, playerSpawnController);
					break;
				}
			}
			if (selectedIntegration != null)
			{
				yield return (object)new WaitUntil((Func<bool>)(() => selectedIntegration.IsComplete));
			}
			LogResults(selectedIntegration);
		}
	}
	public class PlayerSpawnController : MonoBehaviour
	{
		public delegate TResult Func<in T, out TResult>(T arg);

		internal bool CanUpdateLogoutPoint = true;

		internal bool CanRemoveLogoutAfterSync = true;

		internal bool IsTeleportingToDynamicLocation;

		private bool IsRunningFindDynamicZdo;

		public static Dictionary<long, PlayerSpawnController> Instances = new Dictionary<long, PlayerSpawnController>();

		public static PlayerSpawnController? Instance;

		public static Coroutine? MoveToLogoutRoutine;

		public static Coroutine? MoveToSpawnRoutine;

		internal static List<DebugSafeTimer> Timers = new List<DebugSafeTimer>();

		private bool MovePlayerToZdoComplete;

		private static Player? player => Player.m_localPlayer;

		private void Awake()
		{
			Setup();
		}

		private void Update()
		{
			DebugSafeTimer.UpdateTimersFromList(Timers);
		}

		public void DEBUG_MoveTo(LocationVariation locationVariationType)
		{
			CanUpdateLogoutPoint = true;
			CanRemoveLogoutAfterSync = false;
			switch (locationVariationType)
			{
			case LocationVariation.Spawn:
				Instance?.MovePlayerToSpawnPoint();
				break;
			case LocationVariation.Logout:
				Instance?.MovePlayerToLogoutPoint();
				break;
			default:
				throw new ArgumentOutOfRangeException("locationVariationType", locationVariationType, null);
			}
		}

		internal void Reset()
		{
			IsRunningFindDynamicZdo = false;
			IsTeleportingToDynamicLocation = false;
			CanUpdateLogoutPoint = true;
			CanRemoveLogoutAfterSync = true;
			MovePlayerToZdoComplete = true;
			ResetRoutine(ref MoveToLogoutRoutine);
			ResetRoutine(ref MoveToSpawnRoutine);
		}

		internal void OnMovePlayerToZdoComplete(bool success = false, string errorMessage = "OnMovePlayerToZdo exited but failed")
		{
			Reset();
			Timers.Clear();
			IsTeleportingToDynamicLocation = false;
			MovePlayerToZdoComplete = true;
			if (!success)
			{
				Logger.LogError((object)errorMessage);
			}
		}

		internal static void ResetRoutine(ref Coroutine? routine)
		{
			if (routine != null)
			{
				PlayerSpawnController? instance = Instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StopCoroutine(routine);
				}
				routine = null;
			}
		}

		private void OnDestroy()
		{
			Reset();
			Logger.LogDebug((object)"Called onDestroy");
		}

		private void OnDisable()
		{
			Reset();
			((MonoBehaviour)this).StopAllCoroutines();
		}

		private void Setup()
		{
			Instance = this;
			_ = (Object)(object)player == (Object)null;
		}

		public bool PersistDynamicPoint(ZDO zdo, LocationVariation locationVariationType, out int id)
		{
			id = 0;
			if ((Object)(object)ZdoWatchController.Instance == (Object)null)
			{
				return false;
			}
			id = ZdoWatchController.Instance.GetOrCreatePersistentID(zdo);
			if (id != 0)
			{
				Logger.LogError((object)"No persistent ID returned for bed, this should not be possible. Please report this error");
				RemoveDynamicPoint(zdo, locationVariationType);
				return false;
			}
			AddDynamicPoint(zdo, locationVariationType);
			return true;
		}

		public void AddDynamicPoint(ZDO zdo, LocationVariation locationVariationType)
		{
			zdo.Set("DynamicLocations_Point", 1);
		}

		public void RemoveDynamicPoint(ZDO? zdo, LocationVariation locationVariationType)
		{
			LocationController.RemoveZdoTarget(locationVariationType, player);
			if (zdo != null)
			{
				zdo.RemoveInt("DynamicLocations_Point");
			}
		}

		public bool SyncBedSpawnPoint(ZDO zdo, Bed bed)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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)
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (!bed.IsMine() && bed.GetOwner() != 0L)
			{
				return false;
			}
			PersistDynamicPoint(zdo, LocationVariation.Spawn, out var _);
			return LocationController.SetLocationTypeData(LocationVariation.Spawn, player, zdo, ((Component)bed).transform.position - ((Component)player).transform.position);
		}

		public bool SyncLogoutPoint(ZDO? zdo, bool shouldRemove = false)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (zdo == null && !shouldRemove)
			{
				Logger.LogError((object)"ZDO not found for netview, this likely means something is wrong with the are it is being called in");
				return false;
			}
			if (shouldRemove)
			{
				RemoveDynamicPoint(zdo, LocationVariation.Logout);
				Game.instance.m_playerProfile.SavePlayerData(player);
				return true;
			}
			int id;
			bool flag = PersistDynamicPoint(zdo, LocationVariation.Logout, out id);
			if (!shouldRemove && !flag)
			{
				Logger.LogDebug((object)"vehicleZdoId is invalid");
				return false;
			}
			if (LocationController.GetZdoFromStore(LocationVariation.Logout, player) == id)
			{
				Logger.LogDebug((object)"Matching ZDOID found already stored, skipping sync/save");
				return false;
			}
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (((Component)player).transform.localPosition != ((Component)player).transform.position)
			{
				LocationController.SetOffset(LocationVariation.Logout, player, ((Component)player).transform.localPosition);
			}
			LocationController.SetZdo(LocationVariation.Logout, player, zdo);
			Game.instance.m_playerProfile.SavePlayerData(player);
			return true;
		}

		[UsedImplicitly]
		public bool DynamicTeleport(Vector3 position, Quaternion rotation)
		{
			//IL_002e: 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)
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			player.m_teleportCooldown = 15f;
			player.m_teleporting = false;
			return ((Character)player).TeleportTo(position, rotation, !DynamicLocationsConfig.DebugDisableDistancePortal.Value);
		}

		public void MovePlayerToLogoutPoint()
		{
			MoveToLogoutRoutine = ((MonoBehaviour)this).StartCoroutine(UpdateLocation(LocationVariation.Logout));
		}

		public IEnumerator FindDynamicZdo(LocationVariation locationVariationType, Action<ZDO?> onComplete, bool shouldAdjustReferencePoint = false)
		{
			IsRunningFindDynamicZdo = true;
			ZDO zdoOutput = null;
			yield return LocationController.GetZdoFromStoreAsync(locationVariationType, player, delegate(ZDO? output)
			{
				zdoOutput = output;
			});
			onComplete(zdoOutput);
			if (shouldAdjustReferencePoint && (Object)(object)ZNet.instance != (Object)null && zdoOutput != null)
			{
				ZNet.instance.SetReferencePosition(zdoOutput.GetPosition());
			}
			IsRunningFindDynamicZdo = false;
		}

		private IEnumerator UpdateLocation(LocationVariation locationVariationType)
		{
			DebugSafeTimer timer = DebugSafeTimer.StartNew(Timers);
			IsTeleportingToDynamicLocation = false;
			Vector3 offset = LocationController.GetOffset(locationVariationType, player);
			ZDO zdoOutput = null;
			yield return FindDynamicZdo(locationVariationType, delegate(ZDO? output)
			{
				zdoOutput = output;
			});
			if (zdoOutput == null)
			{
				yield break;
			}
			switch (locationVariationType)
			{
			case LocationVariation.Spawn:
				yield return MovePlayerToZdo(zdoOutput, offset);
				break;
			case LocationVariation.Logout:
				yield return LoginAPIController.RunAllIntegrations_OnLoginMoveToZdo(zdoOutput, offset, this);
				break;
			default:
				throw new ArgumentOutOfRangeException("locationVariationType", locationVariationType, null);
			}
			IsTeleportingToDynamicLocation = false;
			LocationVariation locationVariation = locationVariationType;
			if (locationVariation != 0)
			{
				if (locationVariation != LocationVariation.Logout || !((Object)(object)player != (Object)null))
				{
					throw new ArgumentOutOfRangeException("locationVariationType", locationVariationType, null);
				}
				if (CanRemoveLogoutAfterSync && DynamicLocationsConfig.DEBUG_ShouldNotRemoveTargetKey.Value)
				{
					LocationController.RemoveZdoTarget(LocationVariation.Logout, player);
				}
			}
			timer.Clear();
			yield return true;
		}

		public Coroutine MovePlayerToSpawnPoint()
		{
			ResetRoutine(ref MoveToSpawnRoutine);
			ResetRoutine(ref MoveToLogoutRoutine);
			MoveToSpawnRoutine = ((MonoBehaviour)this).StartCoroutine(UpdateLocation(LocationVariation.Spawn));
			return MoveToSpawnRoutine;
		}

		private void SyncPlayerPosition(Vector3 newPosition)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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)
			Logger.LogDebug((object)"Running PlayerPosition Sync");
			if (ZNetView.m_forceDisableInit || (Object)(object)player == (Object)null)
			{
				return;
			}
			ZDO zDO = ((Character)player).m_nview.GetZDO();
			if (zDO == null)
			{
				Logger.LogDebug((object)"Player zdo invalid exiting");
				return;
			}
			Logger.LogDebug((object)$"Syncing Player Position and sector, {newPosition}");
			if (!ZoneSystem.instance.IsZoneLoaded(ZoneSystem.GetZone(newPosition)))
			{
				Logger.LogDebug((object)$"zone not loaded, exiting SyncPlayerPosition for position: {newPosition}");
				return;
			}
			ZNet.instance.SetReferencePosition(newPosition);
			zDO.SetPosition(newPosition);
			zDO.SetSector(ZoneSystem.GetZone(newPosition));
			((Component)player).transform.position = newPosition;
		}

		public static bool HasExpiredTimer(Stopwatch timer, int timeInMs = 1000)
		{
			int num = ((timeInMs > 1000) ? timeInMs : DynamicLocationsConfig.LocationControlsTimeoutInMs.Value);
			return timer.ElapsedMilliseconds > num;
		}

		public static bool HasExpiredTimer(DebugSafeTimer timer, int timeInMs = 1000)
		{
			int num = ((timeInMs > 1000) ? timeInMs : DynamicLocationsConfig.LocationControlsTimeoutInMs.Value);
			return timer.ElapsedMilliseconds > (float)num;
		}

		[UsedImplicitly]
		public bool CanFreezePlayer(bool val)
		{
			return !DynamicLocationsConfig.DebugDisableFreezePlayerTeleportMechanics.Value && val;
		}

		public IEnumerator MovePlayerToZdo(ZDO? zdo, Vector3? offset, bool freezePlayerOnTeleport = false, bool shouldKeepPlayerFrozen = false)
		{
			ZDO zdo2 = zdo;
			if (!Object.op_Implicit((Object)(object)player) || zdo2 == null)
			{
				OnMovePlayerToZdoComplete();
				yield break;
			}
			DebugSafeTimer timer = DebugSafeTimer.StartNew();
			bool hasKinematicPlayerFreeze = CanFreezePlayer(freezePlayerOnTeleport);
			bool hasKeepPlayerFrozen = CanFreezePlayer(shouldKeepPlayerFrozen);
			if (DynamicLocationsConfig.IsDebug)
			{
				Logger.LogDebug((object)"Running MovePlayerToZdo");
			}
			Vector3 val = Vector3.up * (float)DynamicLocationsConfig.RespawnHeightOffset.Value;
			Vector3 position = zdo2.GetPosition() + val;
			IsTeleportingToDynamicLocation = DynamicTeleport(position, zdo2.GetRotation());
			Vector2i zone = ZoneSystem.GetZone(zdo2.GetPosition());
			ZoneSystem.instance.PokeLocalZone(zone);
			bool zoneIsNotLoaded = false;
			while (!zoneIsNotLoaded)
			{
				zone = ZoneSystem.GetZone(zdo2.GetPosition());
				zoneIsNotLoaded = ZoneSystem.instance.IsZoneLoaded(zone);
				yield return (object)new WaitForFixedUpdate();
			}
			if (!IsTeleportingToDynamicLocation)
			{
				OnMovePlayerToZdoComplete();
				Logger.LogError((object)"Teleport command failed for player, exiting dynamic spawn MovePlayerToZdo.");
				yield break;
			}
			if ((Object)(object)player != (Object)null && CanFreezePlayer(freezePlayerOnTeleport) && ((Character)player).IsDebugFlying())
			{
				player.ToggleDebugFly();
			}
			ZNetView zdoNetViewInstance = null;
			zone = ZoneSystem.GetZone(zdo2.GetPosition());
			ZoneSystem.instance.PokeLocalZone(zone);
			yield return (object)new WaitUntil((Func<bool>)(() => !((Character)Player.m_localPlayer).IsTeleporting() || HasExpiredTimer(timer, DynamicLocationsConfig.LocationControlsTimeoutInMs.Value)));
			zdoNetViewInstance = ZNetScene.instance.FindInstance(zdo2);
			yield return (object)new WaitUntil((Func<bool>)delegate
			{
				zdoNetViewInstance = ZNetScene.instance.FindInstance(zdo2);
				return (Object)(object)zdoNetViewInstance != (Object)null || HasExpiredTimer(timer, DynamicLocationsConfig.LocationControlsTimeoutInMs.Value);
			});
			if (HasExpiredTimer(timer, DynamicLocationsConfig.LocationControlsTimeoutInMs.Value))
			{
				Logger.LogError((object)"Error attempting to find NetView instance of the ZDO");
				yield break;
			}
			if ((Object)(object)player != (Object)null && hasKinematicPlayerFreeze && !hasKeepPlayerFrozen && ((Character)player).IsDebugFlying())
			{
				player.ToggleDebugFly();
			}
			if (DynamicLocationsConfig.DebugForceUpdatePositionAfterTeleport.Value && DynamicLocationsConfig.DebugForceUpdatePositionDelay.Value > 0f)
			{
				yield return (object)new WaitForSeconds(DynamicLocationsConfig.DebugForceUpdatePositionDelay.Value);
			}
			if ((Object)(object)player != (Object)null && DynamicLocationsConfig.DebugForceUpdatePositionAfterTeleport.Value)
			{
				ZNetView obj = zdoNetViewInstance;
				Vector3? obj2;
				if (obj == null)
				{
					obj2 = null;
				}
				else
				{
					Vector3 position2 = ((Component)obj).transform.position;
					Vector3? val2 = offset;
					obj2 = (val2.HasValue ? new Vector3?(position2 + val2.GetValueOrDefault()) : null);
				}
				position = (Vector3)(((??)obj2) ?? zdo2.GetPosition()) + Vector3.up * (float)DynamicLocationsConfig.RespawnHeightOffset.Value;
				((Component)player).transform.position = position;
			}
			timer.Clear();
			yield return null;
		}
	}
}
namespace DynamicLocations.Constants
{
	public enum LocationVariation
	{
		Spawn,
		Logout
	}
	public static class LocationVariationUtils
	{
		public const string LogoutString = "logout";

		public const string SpawnString = "spawn";

		public static LocationVariation? ToLocationVaration(string? locationVarationString)
		{
			string text = locationVarationString?.ToLower();
			if (!(text == "logout"))
			{
				if (text == "spawn")
				{
					return LocationVariation.Spawn;
				}
				return null;
			}
			return LocationVariation.Logout;
		}
	}
	public static class ZdoVarKeys
	{
		public const string DynamicLocationsPoint = "DynamicLocations_Point";
	}
}
namespace DynamicLocations.Config
{
	public static class DynamicLocationsConfig
	{
		private const string MainSection = "Main";

		private const string DebugSection = "Debug";

		public static ConfigFile? Config { get; private set; }

		public static ConfigEntry<string> DisabledLoginApiIntegrationsString { get; private set; }

		public static ConfigEntry<int> LocationControlsTimeoutInMs { get; private set; }

		public static List<string> DisabledLoginApiIntegrations => DisabledLoginApiIntegrationsString?.Value.Split(new char[1] { ',' }).ToList() ?? new List<string>();

		public static ConfigEntry<bool> HasCustomSpawnDelay { get; private set; }

		public static ConfigEntry<bool> DEBUG_ShouldNotRemoveTargetKey { get; private set; }

		public static ConfigEntry<float> CustomSpawnDelay { get; private set; }

		public static ConfigEntry<int> RespawnHeightOffset { get; set; }

		public static ConfigEntry<bool> EnableDynamicSpawnPoint { get; private set; }

		public static ConfigEntry<bool> EnableDynamicLogoutPoint { get; private set; }

		public static ConfigEntry<bool> DebugDisableFreezePlayerTeleportMechanics { get; private set; }

		private static ConfigEntry<bool> Debug { get; set; }

		public static bool IsDebug => Debug.Value;

		public static ConfigEntry<bool> DebugDisableDistancePortal { get; private set; }

		public static ConfigEntry<float> DebugForceUpdatePositionDelay { get; private set; }

		public static ConfigEntry<bool> DebugForceUpdatePositionAfterTeleport { get; private set; }

		public static void BindConfig(ConfigFile config)
		{
			//IL_0024: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_007c: 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_0095: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: 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_0133: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Expected O, but got Unknown
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Expected O, but got Unknown
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Expected O, but got Unknown
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Expected O, but got Unknown
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Expected O, but got Unknown
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Expected O, but got Unknown
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Expected O, but got Unknown
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Expected O, but got Unknown
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Expected O, but got Unknown
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Expected O, but got Unknown
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Expected O, but got Unknown
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Expected O, but got Unknown
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Expected O, but got Unknown
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Expected O, but got Unknown
			Config = config;
			DEBUG_ShouldNotRemoveTargetKey = Config.Bind<bool>("Main", "DEBUG_ShouldNotRemoveTargetKey", true, new ConfigDescription("Debug only command: will prevent removing of data on the player. This is meant to debug issues with the player spawn points. Should not be enabled in production builds.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = true
			} }));
			LocationControlsTimeoutInMs = Config.Bind<int>("Main", "LocationControls Timeout In Ms", 20000, new ConfigDescription("Allows for setting the delay in which the spawn will exit logic to prevent degraded performance.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1000, 40000), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = false
			} }));
			HasCustomSpawnDelay = Config.Bind<bool>("Main", "HasCustomSpawnDelay", false, new ConfigDescription("Enables custom spawn delay. This is meant to speed-up the game.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = false
			} }));
			CustomSpawnDelay = Config.Bind<float>("Main", "CustomSpawnDelay", 1f, new ConfigDescription("Will significantly speed-up respawn and login process. This mod will NOT support respawn delays above default(10) seconds, this is too punishing for players. Try to make other consequences instead of preventing people from playing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = false
			} }));
			DisabledLoginApiIntegrationsString = Config.Bind<string>("Main", "DisabledLoginApiIntegrations", "", new ConfigDescription("A list of disabled plugins by GUID or name. Each item must be separated by a comma. This list will force disable any plugins matching either the guid or name. e.g. if you don't want ValheimRAFT to be enabling dynamic locations login integrations add \"zolantris.ValheimRAFT\" or \"ValheimRAFT.2.3.0\".", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = false,
				IsAdvanced = false
			} }));
			DebugDisableFreezePlayerTeleportMechanics = Config.Bind<bool>("Debug", "DEBUG_DisableFreezePlayerMechanics", false, new ConfigDescription("This will disable freezing of players from integrations. Do not disable this unless you know what you are doing. Freezing is used to prevent physics happening during teleport.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = false,
				IsAdvanced = false
			} }));
			DebugDisableDistancePortal = Config.Bind<bool>("Debug", "DebugDistancePortal", false, new ConfigDescription("distance portal enabled, disabling this could break portals", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = true
			} }));
			DebugForceUpdatePositionDelay = Config.Bind<float>("Debug", "DebugForceUpdatePositionDelay", 0f, new ConfigDescription("distance portal enabled, disabling this could break portals", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = true
			} }));
			DebugForceUpdatePositionAfterTeleport = Config.Bind<bool>("Debug", "DebugForceUpdatePositionAfterTeleport", false, new ConfigDescription("distance portal enabled, disabling this could break portals", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = true
			} }));
			EnableDynamicSpawnPoint = Config.Bind<bool>("Main", "enableDynamicSpawnPoints", true, new ConfigDescription("Enable dynamic spawn points. This will allow the user to re-spawn in a new area of the map if a vehicle has moved.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = true
			} }));
			EnableDynamicLogoutPoint = Config.Bind<bool>("Main", "enableDynamicLogoutPoints", true, new ConfigDescription("Enable dynamic logout points. This will allow the user to login to a new area of the map if a vehicle has moved", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = true
			} }));
			RespawnHeightOffset = Config.Bind<int>("Main", "respawnHeightOffset", 0, new ConfigDescription("Sets the respawn height for beds. Useful if the player is spawning within the bed instead of above it", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-5, 10), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = false,
				IsAdvanced = true
			} }));
			Debug = Config.Bind<bool>("Main", "debug", false, new ConfigDescription("Enable additional logging and debug drawing around spawn and logout points. Useful for debugging this mod", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = true
			} }));
			DisabledLoginApiIntegrationsString.SettingChanged += delegate
			{
				LoginAPIController.UpdateIntegrations();
			};
			_ = Debug.Value;
		}
	}
}
namespace DynamicLocations.Commands
{
	public class KeyValueSerializer
	{
		public static string Serialize(object obj, int indentLevel = 0)
		{
			if (obj == null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			string indent = new string(' ', indentLevel * 4);
			Type type = obj.GetType();
			PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				object value = propertyInfo.GetValue(obj);
				SerializeValue(stringBuilder, propertyInfo.Name, value, indent, indentLevel);
			}
			FieldInfo[] array2 = fields;
			foreach (FieldInfo fieldInfo in array2)
			{
				object value2 = fieldInfo.GetValue(obj);
				SerializeValue(stringBuilder, fieldInfo.Name, value2, indent, indentLevel);
			}
			return stringBuilder.ToString();
		}

		private static void SerializeValue(StringBuilder sb, string name, object value, string indent, int indentLevel)
		{
			if (value == null)
			{
				sb.AppendLine(indent + name + ": null");
				return;
			}
			if (value is string || value.GetType().IsPrimitive)
			{
				sb.AppendLine($"{indent}{name}: {value}");
				return;
			}
			if (value is IEnumerable enumerable)
			{
				sb.AppendLine(indent + name + ":");
				{
					foreach (object item in enumerable)
					{
						SerializeValue(sb, "- Item", item, indent + "  ", indentLevel + 1);
					}
					return;
				}
			}
			sb.AppendLine(indent + name + ":");
			sb.Append(Serialize(value, indentLevel + 1));
		}
	}
	public class ListAllKeysCommand : ConsoleCommand
	{
		public override string Name => "list-all-keys";

		public override string Help { get; } = "list all keys";


		public override void Run(string[] args)
		{
			if (args.Length != 0)
			{
				LocationController.DEBUGCOMMAND_ListAllKeys();
			}
		}
	}
	public class ModIntegrationsCommand : ConsoleCommand
	{
		private const string Indent = "\n-  ";

		public override string Name => "mod-integrations";

		public override string Help { get; } = "Lists all mods using this plugin, e.g. ValheimRaft/Vehicles. \n-  Name + version will be output only.\n-  To see everything add -v will output the whole object per integration.";


		private static void ModIntegrationsCommands(bool isVerbose)
		{
			Logger.LogMessage((object)"Listing all integrations by order");
			int num = 1;
			foreach (DynamicLoginIntegration item in LoginAPIController.loginIntegrationsByPriority)
			{
				if (isVerbose)
				{
					Logger.LogMessage((object)KeyValueSerializer.Serialize(item));
				}
				else
				{
					Logger.LogMessage((object)$"[LoginIntegration]: [index: {num}] -> ModName: {item.Name} ModVersion {item.Version}, priority {item.Priority}, guid: {item.Guid}");
				}
				num++;
			}
		}

		private static bool IsVerboseFlag(string arg)
		{
			switch (arg)
			{
			case "-v":
			case "-verbose":
			case "--verbose":
				return true;
			default:
				return false;
			}
		}

		public override void Run(string[] args)
		{
			if (args.Length != 0)
			{
				ModIntegrationsCommands(IsVerboseFlag(args.First()));
			}
		}

		public override List<string> CommandOptionList()
		{
			return new List<string>(1) { "-v" };
		}
	}
	public class MoveToCommand : ConsoleCommand
	{
		public override bool IsCheat => true;

		public override string Name => "move-to";

		public override string Help { get; } = "Moves to logout point. Requires Admin privileges";


		public override void Run(string[] args)
		{
			if (args.Length == 0)
			{
				Logger.LogMessage((object)("Requires an argument of " + string.Join(",", ((ConsoleCommand)this).CommandOptionList().ToArray())));
				return;
			}
			string text = args.First();
			LocationVariation? locationVariation = LocationVariationUtils.ToLocationVaration(text);
			if (!locationVariation.HasValue)
			{
				Logger.LogMessage((object)("Invalid input " + text));
			}
			else
			{
				PlayerSpawnController.Instance?.DEBUG_MoveTo(locationVariation.Value);
			}
		}

		public override List<string> CommandOptionList()
		{
			return new List<string>(2) { "logout", "spawn" };
		}
	}
	public class DynamicLocationsCommands : ConsoleCommand
	{
		private enum CommandsEnum
		{
			Help,
			MoveToLocation,
			ClearAll,
			ClearSpawn,
			ClearLogout,
			ListAllKeys,
			ListIntegrations
		}

		private const string playerClearAllCommand = "playerClearAll";

		private const string playerClearSpawnCommand = "playerClearSpawn";

		private const string playerClearLogoutCommand = "playerClearLogout";

		private const string serverClearAllCommand = "serverClearAll";

		private const string helpCommand = "help";

		private static readonly ListAllKeysCommand ListAllKeysCommandInstance = new ListAllKeysCommand();

		private static readonly ModIntegrationsCommand ModIntegrationsCommandInstance = new ModIntegrationsCommand();

		private static readonly MoveToCommand MoveToCommandInstance = new MoveToCommand();

		private static string helpCommandItems = string.Join("\n", "DynamicLocationsCLI Mod CLI: ", FormatCommand("playerClearLogout") + " removes logout for the current world, will not change other worlds", FormatCommand("playerClearAll") + " clears all dynamicLogin and dynamicSpawn points for a player for the corresponding world", FormatCommand((ConsoleCommand)(object)MoveToCommandInstance), FormatCommand((ConsoleCommand)(object)ListAllKeysCommandInstance), FormatCommand((ConsoleCommand)(object)ModIntegrationsCommandInstance));

		public override string Help => OnHelp();

		public override string Name => "dynamic-locations";

		private static string FormatCommand(string? command)
		{
			if (command != null)
			{
				return "<" + command + ">:";
			}
			return "";
		}

		private static string FormatCommand(string command, List<string>? args, string description)
		{
			return "<" + command + ">: " + string.Join("", args?.Select((string arg) => " " + FormatCommand(arg)) ?? Array.Empty<string>()) + " " + description;
		}

		private static string FormatCommand(ConsoleCommand consoleCommand)
		{
			return FormatCommand(consoleCommand.Name, consoleCommand.CommandOptionList(), consoleCommand.Help);
		}

		private static string OnHelp()
		{
			return helpCommandItems;
		}

		private static CommandsEnum? GetCommandArg(string commandString)
		{
			if (((ConsoleCommand)ModIntegrationsCommandInstance).Name == commandString)
			{
				return CommandsEnum.ListIntegrations;
			}
			if (((ConsoleCommand)ListAllKeysCommandInstance).Name == commandString)
			{
				return CommandsEnum.ListAllKeys;
			}
			if (((ConsoleCommand)MoveToCommandInstance).Name == commandString)
			{
				return CommandsEnum.MoveToLocation;
			}
			return commandString switch
			{
				"playerClearAll" => CommandsEnum.ClearAll, 
				"playerClearLogout" => CommandsEnum.ClearLogout, 
				"help" => CommandsEnum.Help, 
				_ => null, 
			};
		}

		public override void Run(string[] args)
		{
			if (args.Length != 0)
			{
				ParseFirstArg(args);
			}
		}

		private static void ParseFirstArg(string[]? args)
		{
			string text = args?.First() ?? "";
			if (text == "")
			{
				Logger.LogMessage((object)"Must provide a argument for a command. Please run help for more information.");
			}
			CommandsEnum? commandArg = GetCommandArg(text);
			if (!commandArg.HasValue)
			{
				Logger.LogMessage((object)("Command " + text + " not recognized. Please run help for more information."));
				return;
			}
			string[] array = args?.Skip(1)?.ToArray() ?? Array.Empty<string>();
			if (commandArg.HasValue)
			{
				switch (commandArg.GetValueOrDefault())
				{
				case CommandsEnum.ClearAll:
					PlayerClearAll(array);
					break;
				case CommandsEnum.ClearSpawn:
				case CommandsEnum.ClearLogout:
				case CommandsEnum.ListAllKeys:
					((ConsoleCommand)ListAllKeysCommandInstance).Run(array);
					break;
				case CommandsEnum.ListIntegrations:
					((ConsoleCommand)ModIntegrationsCommandInstance).Run(array);
					break;
				case CommandsEnum.Help:
					OnHelp();
					break;
				case CommandsEnum.MoveToLocation:
					((ConsoleCommand)MoveToCommandInstance).Run(array);
					break;
				default:
					throw new ArgumentOutOfRangeException();
				}
			}
		}

		private bool IsAdmin()
		{
			if (!SynchronizationManager.Instance.PlayerIsAdmin)
			{
				Logger.LogMessage((object)"Player is not admin, must be admin to run this command");
				return false;
			}
			return true;
		}

		public static void PlayerClearAll(string[] args)
		{
			if (args.Length == 0)
			{
				LocationController.DEBUG_RemoveAllDynamicLocationKeys();
			}
		}

		public void PlayerListAllDynamicLocationKeys()
		{
			LocationController.DEBUGCOMMAND_ListAllKeys();
		}

		public static void PlayerClearLogout()
		{
			LocationController.DEBUGCOMMAND_RemoveLogout();
		}

		public override List<string> CommandOptionList()
		{
			return new List<string>(5)
			{
				((ConsoleCommand)ListAllKeysCommandInstance).Name,
				((ConsoleCommand)MoveToCommandInstance).Name,
				((ConsoleCommand)ModIntegrationsCommandInstance).Name,
				"playerClearLogout",
				"playerClearAll"
			};
		}
	}
}
namespace DynamicLocations.API
{
	public class DynamicLoginIntegration
	{
		private const int DefaultMovementTimeoutMs = 5000;

		private readonly DebugSafeTimer _timerInstance = new DebugSafeTimer();

		private bool _isRunningOnLoginMoveToZdo;

		private bool _hasCompleted;

		private Coroutine? _onLoginMoveToZdoCoroutine;

		public int LoginPrefabHashCode => Config.LoginPrefabHashCode;

		internal string Guid => Config.Guid;

		internal string Name => Config.Name;

		internal string Version => Config.Version;

		public bool ShouldFreezePlayer => Config.ShouldFreezePlayer;

		public List<string> RunBeforePlugins => Config.RunBeforePlugins;

		public List<string> RunAfterPlugins => Config.RunAfterPlugins;

		public int Priority
		{
			get
			{
				if (Config.Priority <= 0)
				{
					return 999;
				}
				return Config.Priority;
			}
		}

		public int MovementTimeoutMs => GetMovementTimeout();

		public bool IsComplete
		{
			get
			{
				if (_hasCompleted && !_isRunningOnLoginMoveToZdo)
				{
					return _onLoginMoveToZdoCoroutine == null;
				}
				return false;
			}
		}

		public IntegrationConfig Config { get; set; }

		protected DynamicLoginIntegration(IntegrationConfig config)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Config = config;
		}

		private int GetMovementTimeout()
		{
			int movementTimeout = Config.MovementTimeout;
			if (movementTimeout < 2000 || movementTimeout > 20000)
			{
				return 5000;
			}
			return Config.MovementTimeout;
		}

		public static IntegrationConfig CreateConfig(BaseUnityPlugin plugin, string zdoTargetPrefabName)
		{
			return new IntegrationConfig(plugin, zdoTargetPrefabName);
		}

		private void OnStart()
		{
			_timerInstance.Restart();
			PlayerSpawnController.ResetRoutine(ref _onLoginMoveToZdoCoroutine);
			_hasCompleted = false;
			_isRunningOnLoginMoveToZdo = true;
		}

		private void OnComplete()
		{
			_timerInstance.Reset();
			PlayerSpawnController.ResetRoutine(ref _onLoginMoveToZdoCoroutine);
			_isRunningOnLoginMoveToZdo = false;
			_hasCompleted = true;
		}

		protected internal IEnumerator API_OnLoginMoveToZDO(ZDO zdo, Vector3? offset, PlayerSpawnController playerSpawnController)
		{
			OnStart();
			_onLoginMoveToZdoCoroutine = ((MonoBehaviour)playerSpawnController).StartCoroutine(OnLoginMoveToZDO(zdo, offset, playerSpawnController));
			yield return _onLoginMoveToZdoCoroutine;
			yield return (object)new WaitUntil((Func<bool>)(() => _onLoginMoveToZdoCoroutine == null || _timerInstance.ElapsedMilliseconds >= (float)GetMovementTimeout()));
			OnComplete();
			yield return true;
		}

		protected virtual IEnumerator OnLoginMoveToZDO(ZDO zdo, Vector3? offset, PlayerSpawnController playerSpawnController)
		{
			if (DynamicLocationsConfig.IsDebug)
			{
				Logger.LogDebug((object)"Not overridden custom handler, running MovePlayerToZdo default call.");
			}
			if (OnLoginMatchZdoPrefab(zdo))
			{
				yield return playerSpawnController.MovePlayerToZdo(zdo, (Vector3)(((??)offset) ?? Vector3.zero));
				yield return (object)new WaitUntil((Func<bool>)(() => PlayerSpawnController.MoveToLogoutRoutine == null));
			}
		}

		[UsedImplicitly]
		public virtual bool OnLoginMatchZdoPrefab(ZDO zdo)
		{
			if (LoginPrefabHashCode == 0)
			{
				Logger.LogError((object)("Login Prefab Hash was zero, this likely means the mod " + Config.Name + " " + Config.Version + " has not properly been integrated for DynamicLoginIntegration"));
				return false;
			}
			return zdo.GetPrefab() == LoginPrefabHashCode;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}