using System;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace TeleportationMap;

[BepInPlugin("chadi7bark.howtofish.teleportationmap", "Teleportation Map", "0.1.14")]
public sealed class TeleportationMapPlugin : BaseUnityPlugin
{
	private const float WorldToMapXScale = 0.0006040856f;

	private const float WorldToMapXOffset = 0.5680561f;

	private const float WorldToMapZScale = -0.0005951446f;

	private const float WorldToMapZOffset = 0.4647192f;

	private const float LighthouseMapCenterU = 0.459947f;

	private const float LighthouseMapCenterV = 0.094246f;

	private const float LighthouseWorldCenterX = -202.596f;

	private const float LighthouseWorldCenterZ = 601.437f;

	private const float IslandTeleportY = 1.5f;

	private const float AnywhereFallbackY = 3f;

	private const float GroundProbeStartY = 250f;

	private const float GroundProbeDistance = 500f;

	private const float GroundSpawnOffsetY = 1.75f;

	private const int IslandScenePhysicsSettleFrames = 12;

	private const double IslandSceneLoadTimeoutSeconds = 8.0;

	private static readonly string[] IslandNames = new string[5] { "Lighthouse Island", "Shed Island", "Tropical Island", "Casino Island", "Volcano Island" };

	private static readonly float[] IslandWorldX = new float[5] { -200f, 500f, 310f, -150f, -700f };

	private static readonly float[] IslandWorldZ = new float[5] { 600f, -100f, -570f, -770f, -560f };

	private static readonly string[] IslandSceneNames = new string[5] { "Island1", "Island2", "Island3", "Island4", "Island5" };

	private static readonly float[] IslandMapMinU = new float[5] { 0.420707f, 0.836483f, 0.69433f, 0.435497f, 0.064092f };

	private static readonly float[] IslandMapMaxU = new float[5] { 0.486442f, 0.913722f, 0.795399f, 0.527527f, 0.221857f };

	private static readonly float[] IslandMapMinV = new float[5] { 0.08662f, 0.506574f, 0.764114f, 0.887858f, 0.740139f };

	private static readonly float[] IslandMapMaxV = new float[5] { 0.137664f, 0.569219f, 0.846868f, 0.949729f, 0.864656f };

	private static readonly float[] LockedIslandMinX = new float[5] { -219.67f, 479.53f, 276f, -177.33f, -780.6f };

	private static readonly float[] LockedIslandMaxX = new float[5] { -180.26f, 527.49f, 345.83f, -127.74f, -623.63f };

	private static readonly float[] LockedIslandMinZ = new float[5] { 580.5f, -128.28f, -605.58f, -791.01f, -633.57f };

	private static readonly float[] LockedIslandMaxZ = new float[5] { 616.84f, -83.55f, -537.14f, -743.53f, -485.97f };

	private static readonly float[] LighthouseMapPolyU = new float[8] { 0.484f, 0.4785f, 0.4635f, 0.4475f, 0.4408f, 0.446f, 0.46f, 0.476f };

	private static readonly float[] LighthouseMapPolyV = new float[8] { 0.1015f, 0.09f, 0.0868f, 0.0888f, 0.1005f, 0.1105f, 0.119f, 0.112f };

	private static readonly float[] LighthouseWorldPolyX = new float[8] { -180.8f, -187f, -197f, -211.5f, -219f, -212.5f, -199.5f, -186f };

	private static readonly float[] LighthouseWorldPolyZ = new float[8] { 598.5f, 608f, 612f, 608f, 597f, 586f, 581f, 586f };

	private static readonly float[] IslandBoundsScanRadius = new float[5] { 120f, 130f, 150f, 140f, 190f };

	private static readonly float[] GroundProbeOffsetX = new float[21]
	{
		0f, 2f, -2f, 0f, 0f, 2f, 2f, -2f, -2f, 4f,
		-4f, 0f, 0f, 4f, 4f, -4f, -4f, 6f, -6f, 0f,
		0f
	};

	private static readonly float[] GroundProbeOffsetZ = new float[21]
	{
		0f, 0f, 0f, 2f, -2f, 2f, -2f, 2f, -2f, 0f,
		0f, 4f, -4f, 4f, -4f, 4f, -4f, 0f, 0f, 6f,
		-6f
	};

	private object _mapTexture;

	private int _mapWidth = 1217;

	private int _mapHeight = 1293;

	private object _camera;

	private bool _fullMapOpen;

	private float _frozenMapYaw;

	private bool _frozenMapYawValid;

	private bool _oldCursorVisible;

	private object _oldCursorLock;

	private int _frameCounter;

	private Type _inputType;

	private Type _keyCodeType;

	private Type _guiType;

	private Type _rectType;

	private Type _colorType;

	private Type _textureType;

	private Type _texture2DType;

	private Type _textureFormatType;

	private Type _textureWrapModeType;

	private Type _filterModeType;

	private Type _scaleModeType;

	private Type _screenType;

	private Type _cameraType;

	private Type _cursorType;

	private Type _cursorLockModeType;

	private Type _imageConversionType;

	private Type _playerCameraType;

	private Type _playerType;

	private Type _guiStyleType;

	private Type _textAnchorType;

	private Type _guiUtilityType;

	private Type _vector2Type;

	private Type _vector3Type;

	private Type _serverType;

	private Type _physicsType;

	private Type _colliderType;

	private Type _raycastHitType;

	private Type _queryTriggerInteractionType;

	private Type _sceneManagerType;

	private Type _sceneType;

	private Type _loadSceneModeType;

	private object _localPlayer;

	private object _server;

	private object _localPlayerTransform;

	private FieldInfo _playerTransformField;

	private FieldInfo _playerCameraField;

	private FieldInfo _playerCameraRotField;

	private FieldInfo _playerCamObjectField;

	private MethodInfo _serverTeleportPlayer;

	private MethodInfo _playerLocalTeleport;

	private MethodInfo _physicsRaycastAll;

	private MethodInfo _sceneGetByName;

	private MethodInfo _sceneLoadSceneAsync;

	private MethodInfo _sceneLoadScene;

	private string _lastYawSource = "none";

	private object _playerCamera;

	private MethodInfo _toggleMouse;

	private PropertyInfo _playerCameraEnabled;

	private bool _oldPlayerCameraEnabled = true;

	private bool _playerCameraDisabledByMap;

	private MethodInfo _getKeyDown;

	private MethodInfo _getMouseButtonDown;

	private MethodInfo _drawTextureUv;

	private MethodInfo _drawTexture4;

	private MethodInfo _drawTexture2;

	private MethodInfo _label2;

	private MethodInfo _label3;

	private PropertyInfo _guiColor;

	private PropertyInfo _screenWidth;

	private PropertyInfo _screenHeight;

	private PropertyInfo _cameraMain;

	private PropertyInfo _mousePosition;

	private PropertyInfo _cursorVisible;

	private PropertyInfo _cursorLockState;

	private PropertyInfo _guiMatrix;

	private MethodInfo _rotateAroundPivot;

	private object _keyM;

	private object _keyEscape;

	private object _scaleStretch;

	private object _cursorNone;

	private object _whiteTexture;

	private object _whiteColor;

	private object _yellowColor;

	private object _blackColor;

	private object _black78;

	private object _haloColor;

	private object _softGoldColor;

	private object _centerColor;

	private object _indicatorStyle;

	private object _indicatorShadowStyle;

	private object _haloStyle;

	private object _ringStyle;

	private object _centerStyle;

	private int _hoveredIsland = -1;

	private readonly bool[] _islandBoundsValid = new bool[5];

	private readonly float[] _islandMinX = new float[5];

	private readonly float[] _islandMaxX = new float[5];

	private readonly float[] _islandMinZ = new float[5];

	private readonly float[] _islandMaxZ = new float[5];

	private readonly int[] _islandBoundsColliderCount = new int[5];

	private int _pendingTeleportIsland = -1;

	private float _pendingTeleportYaw;

	private float _pendingTeleportWorldX;

	private float _pendingTeleportWorldZ;

	private float _pendingTeleportMapU;

	private float _pendingTeleportMapV;

	private bool _pendingTeleportUseIslandMapping;

	private bool _pendingTeleportPreferIslandLand;

	private bool _pendingSceneLoadRequested;

	private int _pendingSceneReadyFrame = -1;

	private DateTime _pendingTeleportStartedUtc;

	private void LogInfo(string message)
	{
		Console.WriteLine("[Teleportation Map] " + message);
	}

	private void LogWarning(string message)
	{
		Console.WriteLine("[Teleportation Map] [WARNING] " + message);
	}

	private void LogError(string message)
	{
		Console.WriteLine("[Teleportation Map] [ERROR] " + message);
	}

	private void Awake()
	{
		LogInfo("============================================================");
		LogInfo(" TELEPORTATION MAP v0.1.14 BEPINEX / LIGHTHOUSE POLYGON");
		LogInfo(" Author: chadi7bark");
		LogInfo("============================================================");
		LogInfo("M = open/close full map");
		LogInfo("BepInEx 5 port of v0.1.14: locked coordinates + Lighthouse shoreline polygon + triangulated map/world mapping.");
		if (!InitializeUnityApi())
		{
			LogError("Teleportation Map could not initialize the Unity runtime API.");
			return;
		}
		LoadMapTexture();
		RefreshCamera();
		InitializeLockedIslandBounds();
		LogInfo("LIGHTHOUSE POLYGON -> 8 shoreline vertices; raft excluded; anchor map=(0.459947,0.094246) world=(-202.596,601.437).");
	}

	private void Update()
	{
		_frameCounter++;
		ProcessPendingIslandTeleport();
		if (_inputType == null && !InitializeUnityApi())
		{
			return;
		}
		if (GetKeyDown(_keyM))
		{
			if (_fullMapOpen)
			{
				CloseFullMap();
			}
			else
			{
				OpenFullMap();
			}
		}
		if (_fullMapOpen && GetKeyDown(_keyEscape))
		{
			CloseFullMap();
		}
		if (_fullMapOpen && GetMouseButtonDown(0) && TryHandleMapClick())
		{
			return;
		}
		if (_fullMapOpen)
		{
			ForceCursorUnlocked();
			if (_frameCounter % 15 == 0)
			{
				RefreshPlayerCamera();
				if (_playerCamera != null && _playerCameraEnabled != null)
				{
					try
					{
						_playerCameraEnabled.SetValue(_playerCamera, false, null);
					}
					catch
					{
					}
				}
			}
		}
		if (_camera == null || _frameCounter % 30 == 0)
		{
			RefreshCamera();
		}
		else if (_localPlayerTransform == null || _frameCounter % 30 == 0)
		{
			RefreshLocalPlayer();
		}
	}

	private void OnGUI()
	{
		if (_mapTexture != null && !(_guiType == null) && _fullMapOpen)
		{
			DrawFullMap();
		}
	}

	private bool InitializeUnityApi()
	{
		try
		{
			_inputType = ResolveType("UnityEngine.Input", "UnityEngine.InputLegacyModule", "UnityEngine.CoreModule");
			_keyCodeType = ResolveType("UnityEngine.KeyCode", "UnityEngine.InputLegacyModule", "UnityEngine.CoreModule");
			_guiType = ResolveType("UnityEngine.GUI", "UnityEngine.IMGUIModule");
			_rectType = ResolveType("UnityEngine.Rect", "UnityEngine.CoreModule");
			_colorType = ResolveType("UnityEngine.Color", "UnityEngine.CoreModule");
			_textureType = ResolveType("UnityEngine.Texture", "UnityEngine.CoreModule");
			_texture2DType = ResolveType("UnityEngine.Texture2D", "UnityEngine.CoreModule");
			_textureFormatType = ResolveType("UnityEngine.TextureFormat", "UnityEngine.CoreModule");
			_textureWrapModeType = ResolveType("UnityEngine.TextureWrapMode", "UnityEngine.CoreModule");
			_filterModeType = ResolveType("UnityEngine.FilterMode", "UnityEngine.CoreModule");
			_scaleModeType = ResolveType("UnityEngine.ScaleMode", "UnityEngine.IMGUIModule", "UnityEngine.CoreModule");
			_screenType = ResolveType("UnityEngine.Screen", "UnityEngine.CoreModule");
			_cameraType = ResolveType("UnityEngine.Camera", "UnityEngine.CoreModule");
			_cursorType = ResolveType("UnityEngine.Cursor", "UnityEngine.CoreModule");
			_cursorLockModeType = ResolveType("UnityEngine.CursorLockMode", "UnityEngine.CoreModule");
			_imageConversionType = ResolveType("UnityEngine.ImageConversion", "UnityEngine.ImageConversionModule");
			_playerCameraType = ResolveType("PlayerCamera", "Assembly-CSharp");
			_playerType = ResolveType("Player", "Assembly-CSharp");
			_guiStyleType = ResolveType("UnityEngine.GUIStyle", "UnityEngine.IMGUIModule");
			_textAnchorType = ResolveType("UnityEngine.TextAnchor", "UnityEngine.TextRenderingModule", "UnityEngine.CoreModule");
			_guiUtilityType = ResolveType("UnityEngine.GUIUtility", "UnityEngine.IMGUIModule");
			_vector2Type = ResolveType("UnityEngine.Vector2", "UnityEngine.CoreModule");
			_vector3Type = ResolveType("UnityEngine.Vector3", "UnityEngine.CoreModule");
			_serverType = ResolveType("Server", "Assembly-CSharp");
			_physicsType = ResolveType("UnityEngine.Physics", "UnityEngine.PhysicsModule");
			_colliderType = ResolveType("UnityEngine.Collider", "UnityEngine.PhysicsModule");
			_raycastHitType = ResolveType("UnityEngine.RaycastHit", "UnityEngine.PhysicsModule");
			_queryTriggerInteractionType = ResolveType("UnityEngine.QueryTriggerInteraction", "UnityEngine.PhysicsModule");
			_sceneManagerType = ResolveType("UnityEngine.SceneManagement.SceneManager", "UnityEngine.CoreModule");
			_sceneType = ResolveType("UnityEngine.SceneManagement.Scene", "UnityEngine.CoreModule");
			_loadSceneModeType = ResolveType("UnityEngine.SceneManagement.LoadSceneMode", "UnityEngine.CoreModule");
			if (_inputType == null || _keyCodeType == null || _guiType == null || _rectType == null || _colorType == null || _textureType == null || _texture2DType == null || _screenType == null || _cameraType == null)
			{
				return false;
			}
			_getKeyDown = FindStaticMethod(_inputType, "GetKeyDown", new Type[1] { _keyCodeType });
			_getMouseButtonDown = FindStaticMethod(_inputType, "GetMouseButtonDown", new Type[1] { typeof(int) });
			_mousePosition = _inputType.GetProperty("mousePosition", BindingFlags.Static | BindingFlags.Public);
			_drawTextureUv = FindStaticMethod(_guiType, "DrawTextureWithTexCoords", new Type[4]
			{
				_rectType,
				_textureType,
				_rectType,
				typeof(bool)
			});
			_drawTexture4 = ((_scaleModeType == null) ? null : FindStaticMethod(_guiType, "DrawTexture", new Type[4]
			{
				_rectType,
				_textureType,
				_scaleModeType,
				typeof(bool)
			}));
			_drawTexture2 = FindStaticMethod(_guiType, "DrawTexture", new Type[2] { _rectType, _textureType });
			_label2 = FindStaticMethod(_guiType, "Label", new Type[2]
			{
				_rectType,
				typeof(string)
			});
			_label3 = ((_guiStyleType == null) ? null : FindStaticMethod(_guiType, "Label", new Type[3]
			{
				_rectType,
				typeof(string),
				_guiStyleType
			}));
			_guiColor = _guiType.GetProperty("color", BindingFlags.Static | BindingFlags.Public);
			_guiMatrix = _guiType.GetProperty("matrix", BindingFlags.Static | BindingFlags.Public);
			if (_guiUtilityType != null && _vector2Type != null)
			{
				_rotateAroundPivot = FindStaticMethod(_guiUtilityType, "RotateAroundPivot", new Type[2]
				{
					typeof(float),
					_vector2Type
				});
			}
			_screenWidth = _screenType.GetProperty("width", BindingFlags.Static | BindingFlags.Public);
			_screenHeight = _screenType.GetProperty("height", BindingFlags.Static | BindingFlags.Public);
			_cameraMain = _cameraType.GetProperty("main", BindingFlags.Static | BindingFlags.Public);
			if (_cursorType != null)
			{
				_cursorVisible = _cursorType.GetProperty("visible", BindingFlags.Static | BindingFlags.Public);
				_cursorLockState = _cursorType.GetProperty("lockState", BindingFlags.Static | BindingFlags.Public);
			}
			_keyM = Enum.Parse(_keyCodeType, "M");
			_keyEscape = Enum.Parse(_keyCodeType, "Escape");
			if (_scaleModeType != null)
			{
				_scaleStretch = Enum.Parse(_scaleModeType, "StretchToFill");
			}
			if (_cursorLockModeType != null)
			{
				_cursorNone = Enum.Parse(_cursorLockModeType, "None");
			}
			_whiteColor = NewColor(1f, 1f, 1f, 1f);
			_yellowColor = NewColor(0.97f, 0.83f, 0.18f, 1f);
			_blackColor = NewColor(0f, 0f, 0f, 1f);
			_black78 = NewColor(0f, 0f, 0f, 0.78f);
			_haloColor = NewColor(0f, 0f, 0f, 0.58f);
			_softGoldColor = NewColor(1f, 0.72f, 0.1f, 0.95f);
			_centerColor = NewColor(1f, 0.96f, 0.72f, 1f);
			PropertyInfo property = _texture2DType.GetProperty("whiteTexture", BindingFlags.Static | BindingFlags.Public);
			if (property != null)
			{
				_whiteTexture = property.GetValue(null, null);
			}
			BuildIndicatorStyles(32);
			ResolveTeleportApi();
			ResolvePhysicsApi();
			ResolveSceneApi();
			return _getKeyDown != null && _screenWidth != null && _screenHeight != null && _label2 != null;
		}
		catch (Exception ex)
		{
			LogError("Unity reflection setup failed: " + ex);
			return false;
		}
	}

	private void LoadMapTexture()
	{
		string text = Path.Combine(Environment.CurrentDirectory, "UserData", "TeleportationMap", "TeleportationMap.png");
		if (!File.Exists(text))
		{
			LogError("Map image was not found: " + text);
			return;
		}
		try
		{
			object obj = CreateTexture2D();
			if (obj == null)
			{
				LogError("Could not construct Unity Texture2D.");
				return;
			}
			SetPropertyIfPresent(obj, "name", "TeleportationMapTexture");
			if (_textureWrapModeType != null)
			{
				SetPropertyIfPresent(obj, "wrapMode", Enum.Parse(_textureWrapModeType, "Clamp"));
			}
			if (_filterModeType != null)
			{
				SetPropertyIfPresent(obj, "filterMode", Enum.Parse(_filterModeType, "Bilinear"));
			}
			byte[] data = File.ReadAllBytes(text);
			if (!LoadPngIntoTexture(obj, data))
			{
				LogError("Unity could not decode TeleportationMap.png.");
				return;
			}
			_mapTexture = obj;
			_mapWidth = ReadIntProperty(obj, "width", _mapWidth);
			_mapHeight = ReadIntProperty(obj, "height", _mapHeight);
			LogInfo("Loaded custom map texture: " + _mapWidth + "x" + _mapHeight);
		}
		catch (Exception ex)
		{
			LogError("Failed to load map texture: " + ex);
		}
	}

	private object CreateTexture2D()
	{
		try
		{
			if (_textureFormatType != null)
			{
				object obj = Enum.Parse(_textureFormatType, "RGBA32");
				ConstructorInfo constructor = _texture2DType.GetConstructor(new Type[4]
				{
					typeof(int),
					typeof(int),
					_textureFormatType,
					typeof(bool)
				});
				if (constructor != null)
				{
					return constructor.Invoke(new object[4] { 2, 2, obj, false });
				}
			}
			ConstructorInfo constructor2 = _texture2DType.GetConstructor(new Type[2]
			{
				typeof(int),
				typeof(int)
			});
			if (constructor2 != null)
			{
				return constructor2.Invoke(new object[2] { 2, 2 });
			}
		}
		catch (Exception ex)
		{
			LogError("Texture2D constructor failed: " + ex);
		}
		return null;
	}

	private bool LoadPngIntoTexture(object texture, byte[] data)
	{
		if (_imageConversionType == null)
		{
			_imageConversionType = ResolveType("UnityEngine.ImageConversion", "UnityEngine.ImageConversionModule");
		}
		_playerCameraType = ResolveType("PlayerCamera", "Assembly-CSharp");
		_playerType = ResolveType("Player", "Assembly-CSharp");
		_guiStyleType = ResolveType("UnityEngine.GUIStyle", "UnityEngine.IMGUIModule");
		_textAnchorType = ResolveType("UnityEngine.TextAnchor", "UnityEngine.TextRenderingModule", "UnityEngine.CoreModule");
		_guiUtilityType = ResolveType("UnityEngine.GUIUtility", "UnityEngine.IMGUIModule");
		_vector2Type = ResolveType("UnityEngine.Vector2", "UnityEngine.CoreModule");
		if (_imageConversionType == null)
		{
			return false;
		}
		MethodInfo[] methods = _imageConversionType.GetMethods(BindingFlags.Static | BindingFlags.Public);
		foreach (MethodInfo methodInfo in methods)
		{
			if (methodInfo.Name != "LoadImage")
			{
				continue;
			}
			ParameterInfo[] parameters = methodInfo.GetParameters();
			if (parameters.Length == 3 && !(parameters[0].ParameterType.FullName != "UnityEngine.Texture2D") && !(parameters[1].ParameterType != typeof(byte[])) && !(parameters[2].ParameterType != typeof(bool)))
			{
				object obj = methodInfo.Invoke(null, new object[3] { texture, data, false });
				if (obj is bool)
				{
					return (bool)obj;
				}
				return false;
			}
		}
		return false;
	}

	private void RefreshCamera()
	{
		try
		{
			if (_cameraMain != null)
			{
				_camera = _cameraMain.GetValue(null, null);
			}
			RefreshPlayerCamera();
			RefreshLocalPlayer();
		}
		catch
		{
			_camera = null;
		}
	}

	private void DrawFullMap()
	{
		int screenWidth = GetScreenWidth();
		int screenHeight = GetScreenHeight();
		DrawSolidRect(0f, 0f, screenWidth, screenHeight, _black78);
		GetMapRect(screenWidth, screenHeight, out var mapX, out var mapY, out var mapW, out var mapH);
		object rect = NewRect(mapX, mapY, mapW, mapH);
		SetGuiColor(_whiteColor);
		DrawTexture(rect, _mapTexture);
		GetNavigationState(out var x, out var z, out var yawDegrees);
		if (_frozenMapYawValid)
		{
			yawDegrees = _frozenMapYaw;
		}
		WorldToMapNormalizedAuto(x, z, out var u, out var screenV, out var _);
		float centerX = mapX + u * mapW;
		float centerY = mapY + screenV * mapH;
		DrawPlayerIndicator(centerX, centerY, yawDegrees, Clamp(mapW * 0.035f, 26f, 46f));
		_hoveredIsland = FindIslandUnderMouse(mapX, mapY, mapW, mapH);
		SetGuiColor(_whiteColor);
		DrawLabel(NewRect(12f, 10f, (float)screenWidth - 24f, 28f), "TELEPORTATION MAP");
		string text;
		if (TryGetMapMouseWorld(mapX, mapY, mapW, mapH, out var worldX, out var worldZ))
		{
			int num = FindNearestIsland(worldX, worldZ);
			text = "LEFT CLICK TO TELEPORT  |  X=" + worldX.ToString("0") + " Z=" + worldZ.ToString("0");
			if (_hoveredIsland >= 0)
			{
				text = text + "  |  " + IslandNames[_hoveredIsland];
				text = ((!_islandBoundsValid[_hoveredIsland]) ? (text + " locked mapping") : (text + " LOCKED-MAPPED"));
			}
			else if (num >= 0)
			{
				text = text + "  |  nearest: " + IslandNames[num];
			}
		}
		else
		{
			text = "LEFT CLICK ANYWHERE ON THE MAP TO TELEPORT  |  M or ESC = close";
		}
		DrawLabel(NewRect(12f, (float)screenHeight - 30f, (float)screenWidth - 24f, 24f), text);
	}

	private bool TryHandleMapClick()
	{
		int screenWidth = GetScreenWidth();
		int screenHeight = GetScreenHeight();
		GetMapRect(screenWidth, screenHeight, out var mapX, out var mapY, out var mapW, out var mapH);
		if (!TryGetMapMouseNormalized(mapX, mapY, mapW, mapH, out var u, out var v))
		{
			return false;
		}
		int num = FindIslandAtNormalized(u, v);
		bool preferIslandLand = num >= 0;
		MapNormalizedToWorldAuto(u, v, out var worldX, out var worldZ, out var mappedIsland);
		int num2 = num;
		if (num2 < 0)
		{
			num2 = mappedIsland;
		}
		if (num2 < 0)
		{
			num2 = FindNearestIsland(worldX, worldZ);
		}
		if (num2 < 0)
		{
			return false;
		}
		float yaw = (_frozenMapYawValid ? _frozenMapYaw : 0f);
		if (!BeginMapTeleport(worldX, worldZ, num2, yaw, preferIslandLand, u, v, num >= 0))
		{
			return false;
		}
		LogInfo("ANYWHERE CLICK -> map=(" + u.ToString("0.0000") + "," + v.ToString("0.0000") + ") world=(" + worldX.ToString("0.00") + ", " + worldZ.ToString("0.00") + ") scene=" + IslandSceneNames[num2] + ((num >= 0) ? "; ISLAND-LOCAL LOCKED BOUNDS requested." : "; global ocean mapping requested."));
		CloseFullMap();
		return true;
	}

	private bool TryGetMapMouseNormalized(float mapX, float mapY, float mapW, float mapH, out float u, out float v)
	{
		u = 0f;
		v = 0f;
		if (!TryGetGuiMousePosition(out var x, out var y))
		{
			return false;
		}
		if (mapW <= 0.01f || mapH <= 0.01f)
		{
			return false;
		}
		if (x < mapX || x > mapX + mapW || y < mapY || y > mapY + mapH)
		{
			return false;
		}
		u = Clamp((x - mapX) / mapW, 0.045f, 0.955f);
		v = Clamp((y - mapY) / mapH, 0.04f, 0.955f);
		return true;
	}

	private bool TryGetMapMouseWorld(float mapX, float mapY, float mapW, float mapH, out float worldX, out float worldZ)
	{
		worldX = 0f;
		worldZ = 0f;
		if (!TryGetMapMouseNormalized(mapX, mapY, mapW, mapH, out var u, out var v))
		{
			return false;
		}
		MapNormalizedToWorldAuto(u, v, out worldX, out worldZ, out var _);
		return true;
	}

	private int FindNearestIsland(float worldX, float worldZ)
	{
		int result = -1;
		float num = float.MaxValue;
		for (int i = 0; i < IslandWorldX.Length && i < IslandWorldZ.Length; i++)
		{
			float num2 = worldX - IslandWorldX[i];
			float num3 = worldZ - IslandWorldZ[i];
			float num4 = num2 * num2 + num3 * num3;
			if (num4 < num)
			{
				num = num4;
				result = i;
			}
		}
		return result;
	}

	private int FindIslandUnderMouse(float mapX, float mapY, float mapW, float mapH)
	{
		if (!TryGetMapMouseNormalized(mapX, mapY, mapW, mapH, out var u, out var v))
		{
			return -1;
		}
		return FindIslandAtNormalized(u, v);
	}

	private int FindIslandAtNormalized(float u, float v)
	{
		if (IsPointInLighthouseMapPolygon(u, v))
		{
			return 0;
		}
		for (int i = 1; i < IslandNames.Length; i++)
		{
			float num = IslandMapMinU[i];
			float num2 = IslandMapMaxU[i];
			float num3 = IslandMapMinV[i];
			float num4 = IslandMapMaxV[i];
			float num5 = (num + num2) * 0.5f;
			float num6 = (num3 + num4) * 0.5f;
			float num7 = Math.Max((num2 - num) * 0.54f, 0.001f);
			float num8 = Math.Max((num4 - num3) * 0.54f, 0.001f);
			float num9 = (u - num5) / num7;
			float num10 = (v - num6) / num8;
			if (num9 * num9 + num10 * num10 <= 1f)
			{
				return i;
			}
		}
		return -1;
	}

	private bool IsPointInLighthouseMapPolygon(float u, float v)
	{
		bool flag = false;
		int num = LighthouseMapPolyU.Length;
		int num2 = num - 1;
		for (int i = 0; i < num; i++)
		{
			float num3 = LighthouseMapPolyU[i];
			float num4 = LighthouseMapPolyV[i];
			float num5 = LighthouseMapPolyU[num2];
			float num6 = LighthouseMapPolyV[num2];
			if (num4 > v != num6 > v)
			{
				float num7 = num6 - num4;
				if (Math.Abs(num7) < 1E-07f)
				{
					num7 = ((num7 < 0f) ? (-1E-07f) : 1E-07f);
				}
				float num8 = (num5 - num3) * (v - num4) / num7 + num3;
				if (u < num8)
				{
					flag = !flag;
				}
			}
			num2 = i;
		}
		return flag;
	}

	private bool TryMapLighthouseMapToWorld(float u, float v, out float worldX, out float worldZ)
	{
		worldX = 0f;
		worldZ = 0f;
		if (!IsPointInLighthouseMapPolygon(u, v))
		{
			return false;
		}
		int num = LighthouseMapPolyU.Length;
		for (int i = 0; i < num; i++)
		{
			int num2 = (i + 1) % num;
			if (TryBarycentric2D(u, v, 0.459947f, 0.094246f, LighthouseMapPolyU[i], LighthouseMapPolyV[i], LighthouseMapPolyU[num2], LighthouseMapPolyV[num2], out var wa, out var wb, out var wc))
			{
				worldX = wa * -202.596f + wb * LighthouseWorldPolyX[i] + wc * LighthouseWorldPolyX[num2];
				worldZ = wa * 601.437f + wb * LighthouseWorldPolyZ[i] + wc * LighthouseWorldPolyZ[num2];
				return true;
			}
		}
		return false;
	}

	private bool TryMapLighthouseWorldToMap(float worldX, float worldZ, out float u, out float v)
	{
		u = 0f;
		v = 0f;
		int num = LighthouseWorldPolyX.Length;
		for (int i = 0; i < num; i++)
		{
			int num2 = (i + 1) % num;
			if (TryBarycentric2D(worldX, worldZ, -202.596f, 601.437f, LighthouseWorldPolyX[i], LighthouseWorldPolyZ[i], LighthouseWorldPolyX[num2], LighthouseWorldPolyZ[num2], out var wa, out var wb, out var wc))
			{
				u = wa * 0.459947f + wb * LighthouseMapPolyU[i] + wc * LighthouseMapPolyU[num2];
				v = wa * 0.094246f + wb * LighthouseMapPolyV[i] + wc * LighthouseMapPolyV[num2];
				return true;
			}
		}
		return false;
	}

	private static bool TryBarycentric2D(float px, float py, float ax, float ay, float bx, float by, float cx, float cy, out float wa, out float wb, out float wc)
	{
		wa = 0f;
		wb = 0f;
		wc = 0f;
		float num = bx - ax;
		float num2 = by - ay;
		float num3 = cx - ax;
		float num4 = cy - ay;
		float num5 = px - ax;
		float num6 = py - ay;
		float num7 = num * num + num2 * num2;
		float num8 = num * num3 + num2 * num4;
		float num9 = num3 * num3 + num4 * num4;
		float num10 = num5 * num + num6 * num2;
		float num11 = num5 * num3 + num6 * num4;
		float num12 = num7 * num9 - num8 * num8;
		if (Math.Abs(num12) < 1E-08f)
		{
			return false;
		}
		wb = (num9 * num10 - num8 * num11) / num12;
		wc = (num7 * num11 - num8 * num10) / num12;
		wa = 1f - wb - wc;
		if (wa >= -0.0006f && wb >= -0.0006f)
		{
			return wc >= -0.0006f;
		}
		return false;
	}

	private bool TryGetGuiMousePosition(out float x, out float y)
	{
		x = 0f;
		y = 0f;
		if (_mousePosition == null)
		{
			return false;
		}
		try
		{
			object value = _mousePosition.GetValue(null, null);
			if (value == null)
			{
				return false;
			}
			FieldInfo field = value.GetType().GetField("x", BindingFlags.Instance | BindingFlags.Public);
			FieldInfo field2 = value.GetType().GetField("y", BindingFlags.Instance | BindingFlags.Public);
			if (field == null || field2 == null)
			{
				return false;
			}
			x = Convert.ToSingle(field.GetValue(value));
			y = (float)GetScreenHeight() - Convert.ToSingle(field2.GetValue(value));
			return true;
		}
		catch
		{
			return false;
		}
	}

	private void GetMapRect(int screenW, int screenH, out float mapX, out float mapY, out float mapW, out float mapH)
	{
		float num = (float)screenW * 0.63f;
		float num2 = (float)screenH * 0.63f;
		float num3 = ((_mapHeight <= 0) ? 1f : ((float)_mapWidth / (float)_mapHeight));
		mapW = num;
		mapH = mapW / num3;
		if (mapH > num2)
		{
			mapH = num2;
			mapW = mapH * num3;
		}
		mapX = ((float)screenW - mapW) * 0.5f;
		mapY = ((float)screenH - mapH) * 0.5f + 10f;
	}

	private void ResolveSceneApi()
	{
		if (_sceneManagerType == null)
		{
			_sceneManagerType = ResolveType("UnityEngine.SceneManagement.SceneManager", "UnityEngine.CoreModule");
		}
		if (_sceneType == null)
		{
			_sceneType = ResolveType("UnityEngine.SceneManagement.Scene", "UnityEngine.CoreModule");
		}
		if (_loadSceneModeType == null)
		{
			_loadSceneModeType = ResolveType("UnityEngine.SceneManagement.LoadSceneMode", "UnityEngine.CoreModule");
		}
		if (_sceneManagerType == null)
		{
			return;
		}
		try
		{
			_sceneGetByName = _sceneManagerType.GetMethod("GetSceneByName", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
			if (_loadSceneModeType != null)
			{
				_sceneLoadSceneAsync = _sceneManagerType.GetMethod("LoadSceneAsync", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(string),
					_loadSceneModeType
				}, null);
				_sceneLoadScene = _sceneManagerType.GetMethod("LoadScene", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(string),
					_loadSceneModeType
				}, null);
			}
		}
		catch
		{
		}
	}

	private bool BeginMapTeleport(float worldX, float worldZ, int island, float yaw, bool preferIslandLand, float mapU, float mapV, bool useIslandMapping)
	{
		if (island < 0 || island >= IslandNames.Length)
		{
			return false;
		}
		if (_pendingTeleportIsland >= 0)
		{
			LogWarning("A map teleport is already waiting for an island scene to load.");
			return false;
		}
		_pendingTeleportIsland = island;
		_pendingTeleportYaw = yaw;
		_pendingTeleportWorldX = worldX;
		_pendingTeleportWorldZ = worldZ;
		_pendingTeleportMapU = mapU;
		_pendingTeleportMapV = mapV;
		_pendingTeleportUseIslandMapping = useIslandMapping;
		_pendingTeleportPreferIslandLand = preferIslandLand;
		_pendingSceneLoadRequested = false;
		_pendingSceneReadyFrame = -1;
		_pendingTeleportStartedUtc = DateTime.UtcNow;
		string text = IslandSceneNames[island];
		if (IsSceneLoaded(text))
		{
			_pendingSceneReadyFrame = _frameCounter + 12;
			LogInfo("Nearest island scene already loaded -> " + text + "; waiting briefly for physics before point ground scan.");
		}
		else
		{
			RequestIslandSceneLoad(text);
		}
		return true;
	}

	private void ProcessPendingIslandTeleport()
	{
		if (_pendingTeleportIsland < 0)
		{
			return;
		}
		if (_pendingTeleportIsland >= IslandNames.Length)
		{
			ClearPendingIslandTeleport();
			return;
		}
		int pendingTeleportIsland = _pendingTeleportIsland;
		string text = IslandSceneNames[pendingTeleportIsland];
		if (!IsSceneLoaded(text))
		{
			if (!_pendingSceneLoadRequested)
			{
				RequestIslandSceneLoad(text);
			}
			if (!((DateTime.UtcNow - _pendingTeleportStartedUtc).TotalSeconds < 8.0))
			{
				LogWarning("Timed out waiting for " + text + "; teleporting with the original fallback if ground is still unavailable.");
				float pendingTeleportYaw = _pendingTeleportYaw;
				float worldX = _pendingTeleportWorldX;
				float worldZ = _pendingTeleportWorldZ;
				bool pendingTeleportPreferIslandLand = _pendingTeleportPreferIslandLand;
				if (_pendingTeleportUseIslandMapping && ScanIslandWorldBounds(pendingTeleportIsland))
				{
					MapIslandNormalizedToWorld(pendingTeleportIsland, _pendingTeleportMapU, _pendingTeleportMapV, out worldX, out worldZ);
				}
				ClearPendingIslandTeleport();
				TeleportToMapPoint(worldX, worldZ, pendingTeleportIsland, pendingTeleportYaw, text, pendingTeleportPreferIslandLand);
			}
		}
		else if (_pendingSceneReadyFrame < 0)
		{
			_pendingSceneReadyFrame = _frameCounter + 12;
			LogInfo("ISLAND SCENE READY -> " + text + "; waiting " + 12 + " frames for colliders.");
		}
		else if (_frameCounter >= _pendingSceneReadyFrame)
		{
			ScanIslandWorldBounds(pendingTeleportIsland);
			float pendingTeleportYaw2 = _pendingTeleportYaw;
			float worldX2 = _pendingTeleportWorldX;
			float worldZ2 = _pendingTeleportWorldZ;
			bool pendingTeleportPreferIslandLand2 = _pendingTeleportPreferIslandLand;
			if (_pendingTeleportUseIslandMapping && _islandBoundsValid[pendingTeleportIsland])
			{
				MapIslandNormalizedToWorld(pendingTeleportIsland, _pendingTeleportMapU, _pendingTeleportMapV, out worldX2, out worldZ2);
				LogInfo("LOCKED ISLAND REMAP -> " + IslandNames[pendingTeleportIsland] + " world=(" + worldX2.ToString("0.00") + ", " + worldZ2.ToString("0.00") + ")");
			}
			ClearPendingIslandTeleport();
			TeleportToMapPoint(worldX2, worldZ2, pendingTeleportIsland, pendingTeleportYaw2, text, pendingTeleportPreferIslandLand2);
		}
	}

	private void ClearPendingIslandTeleport()
	{
		_pendingTeleportIsland = -1;
		_pendingTeleportYaw = 0f;
		_pendingTeleportWorldX = 0f;
		_pendingTeleportWorldZ = 0f;
		_pendingTeleportMapU = 0f;
		_pendingTeleportMapV = 0f;
		_pendingTeleportUseIslandMapping = false;
		_pendingTeleportPreferIslandLand = false;
		_pendingSceneLoadRequested = false;
		_pendingSceneReadyFrame = -1;
	}

	private bool IsSceneLoaded(string sceneName)
	{
		if (string.IsNullOrEmpty(sceneName))
		{
			return false;
		}
		if (_sceneGetByName == null)
		{
			ResolveSceneApi();
		}
		if (_sceneGetByName == null)
		{
			return false;
		}
		try
		{
			object obj = _sceneGetByName.Invoke(null, new object[1] { sceneName });
			if (obj == null)
			{
				return false;
			}
			PropertyInfo property = obj.GetType().GetProperty("isLoaded", BindingFlags.Instance | BindingFlags.Public);
			if (property != null)
			{
				return Convert.ToBoolean(property.GetValue(obj, null));
			}
		}
		catch
		{
		}
		return false;
	}

	private bool RequestIslandSceneLoad(string sceneName)
	{
		if (string.IsNullOrEmpty(sceneName))
		{
			return false;
		}
		if (_sceneManagerType == null || (_sceneLoadSceneAsync == null && _sceneLoadScene == null))
		{
			ResolveSceneApi();
		}
		if (_sceneManagerType == null || _loadSceneModeType == null)
		{
			return false;
		}
		_pendingSceneLoadRequested = true;
		try
		{
			object obj = Enum.Parse(_loadSceneModeType, "Additive");
			if (_sceneLoadSceneAsync != null)
			{
				_sceneLoadSceneAsync.Invoke(null, new object[2] { sceneName, obj });
				LogInfo("ADDITIVE ISLAND LOAD -> " + sceneName + " requested; waiting for scene + collision before teleport.");
				return true;
			}
			if (_sceneLoadScene != null)
			{
				_sceneLoadScene.Invoke(null, new object[2] { sceneName, obj });
				LogInfo("ADDITIVE ISLAND LOAD -> " + sceneName + " requested synchronously.");
				return true;
			}
		}
		catch (Exception ex)
		{
			LogWarning("Could not request island scene load for " + sceneName + ": " + ex.Message);
		}
		return false;
	}

	private void InitializeLockedIslandBounds()
	{
		for (int i = 0; i < IslandNames.Length; i++)
		{
			_islandMinX[i] = LockedIslandMinX[i];
			_islandMaxX[i] = LockedIslandMaxX[i];
			_islandMinZ[i] = LockedIslandMinZ[i];
			_islandMaxZ[i] = LockedIslandMaxZ[i];
			_islandBoundsColliderCount[i] = -1;
			_islandBoundsValid[i] = true;
			LogInfo("LOCKED ISLAND BOUNDS -> " + IslandNames[i] + " X=[" + _islandMinX[i].ToString("0.00") + "," + _islandMaxX[i].ToString("0.00") + "] Z=[" + _islandMinZ[i].ToString("0.00") + "," + _islandMaxZ[i].ToString("0.00") + "]");
		}
	}

	private void RefreshLoadedIslandBounds()
	{
	}

	private bool ScanIslandWorldBounds(int island)
	{
		if (island >= 0 && island < IslandNames.Length)
		{
			return _islandBoundsValid[island];
		}
		return false;
	}

	private static bool LooksLikeIslandTerrainCollider(string name)
	{
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		string text = name.ToLowerInvariant();
		string[] array = new string[9] { "island", "terrain", "ground", "rock", "cliff", "sand", "beach", "shore", "land" };
		for (int i = 0; i < array.Length; i++)
		{
			if (text.IndexOf(array[i], StringComparison.Ordinal) >= 0)
			{
				return true;
			}
		}
		return false;
	}

	private void WorldToMapNormalizedAuto(float worldX, float worldZ, out float u, out float screenV, out int mappedIsland)
	{
		if (IsWorldPointNearIslandBounds(0, worldX, worldZ, 8f) && TryMapLighthouseWorldToMap(worldX, worldZ, out u, out screenV))
		{
			mappedIsland = 0;
			return;
		}
		mappedIsland = FindNearestIsland(worldX, worldZ);
		if (mappedIsland >= 0 && mappedIsland < IslandNames.Length && _islandBoundsValid[mappedIsland] && IsWorldPointNearIslandBounds(mappedIsland, worldX, worldZ, 16f))
		{
			float num = InverseLerp(_islandMinX[mappedIsland], _islandMaxX[mappedIsland], worldX);
			float num2 = InverseLerp(_islandMinZ[mappedIsland], _islandMaxZ[mappedIsland], worldZ);
			u = IslandMapMinU[mappedIsland] + num * (IslandMapMaxU[mappedIsland] - IslandMapMinU[mappedIsland]);
			screenV = IslandMapMaxV[mappedIsland] - num2 * (IslandMapMaxV[mappedIsland] - IslandMapMinV[mappedIsland]);
		}
		else
		{
			mappedIsland = -1;
			WorldToMapNormalized(worldX, worldZ, out u, out screenV);
		}
	}

	private void MapNormalizedToWorldAuto(float u, float screenV, out float worldX, out float worldZ, out int mappedIsland)
	{
		if (TryMapLighthouseMapToWorld(u, screenV, out worldX, out worldZ))
		{
			mappedIsland = 0;
			return;
		}
		mappedIsland = FindIslandAtNormalized(u, screenV);
		if (mappedIsland >= 0 && mappedIsland < IslandNames.Length && _islandBoundsValid[mappedIsland])
		{
			MapIslandNormalizedToWorld(mappedIsland, u, screenV, out worldX, out worldZ);
			return;
		}
		mappedIsland = -1;
		MapNormalizedToWorld(u, screenV, out worldX, out worldZ);
	}

	private void MapIslandNormalizedToWorld(int island, float u, float screenV, out float worldX, out float worldZ)
	{
		if (island != 0 || !TryMapLighthouseMapToWorld(u, screenV, out worldX, out worldZ))
		{
			if (island < 0 || island >= IslandNames.Length || !_islandBoundsValid[island])
			{
				MapNormalizedToWorld(u, screenV, out worldX, out worldZ);
				return;
			}
			float num = InverseLerp(IslandMapMinU[island], IslandMapMaxU[island], u);
			float num2 = InverseLerp(IslandMapMaxV[island], IslandMapMinV[island], screenV);
			worldX = _islandMinX[island] + num * (_islandMaxX[island] - _islandMinX[island]);
			worldZ = _islandMinZ[island] + num2 * (_islandMaxZ[island] - _islandMinZ[island]);
		}
	}

	private bool IsWorldPointNearIslandBounds(int island, float worldX, float worldZ, float padding)
	{
		if (island < 0 || island >= IslandNames.Length || !_islandBoundsValid[island])
		{
			return false;
		}
		if (worldX >= _islandMinX[island] - padding && worldX <= _islandMaxX[island] + padding && worldZ >= _islandMinZ[island] - padding)
		{
			return worldZ <= _islandMaxZ[island] + padding;
		}
		return false;
	}

	private void ResolveTeleportApi()
	{
		if (_serverType == null)
		{
			_serverType = ResolveType("Server", "Assembly-CSharp");
		}
		if (_playerType == null)
		{
			_playerType = ResolveType("Player", "Assembly-CSharp");
		}
		if (_vector3Type == null)
		{
			_vector3Type = ResolveType("UnityEngine.Vector3", "UnityEngine.CoreModule");
		}
		if (_serverType != null && _playerType != null && _vector3Type != null)
		{
			_serverTeleportPlayer = _serverType.GetMethod("TeleportPlayer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				_playerType,
				_vector3Type,
				typeof(float)
			}, null);
		}
		if (_playerType != null && _vector3Type != null)
		{
			_playerLocalTeleport = _playerType.GetMethod("LocalTeleport", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				_vector3Type,
				typeof(float),
				typeof(bool)
			}, null);
		}
	}

	private void RefreshServer()
	{
		if (_serverType == null)
		{
			_serverType = ResolveType("Server", "Assembly-CSharp");
		}
		if (_serverType == null)
		{
			return;
		}
		try
		{
			Array array = FindUnityObjectsOfType(_serverType);
			if (array == null || array.Length == 0)
			{
				return;
			}
			object obj = null;
			for (int i = 0; i < array.Length; i++)
			{
				object value = array.GetValue(i);
				if (value != null)
				{
					if (obj == null)
					{
						obj = value;
					}
					if (ReadStringProperty(value, "name") == "Server(Clone)")
					{
						_server = value;
						return;
					}
				}
			}
			_server = obj;
		}
		catch
		{
		}
	}

	private bool TeleportToMapPoint(float requestedX, float requestedZ, int nearestIsland, float yaw, string requiredSceneName, bool preferIslandLand)
	{
		if (_localPlayer == null)
		{
			RefreshLocalPlayer();
		}
		if (_localPlayer == null)
		{
			LogWarning("Teleport failed: live PlayerHolder(Clone) was not found.");
			return false;
		}
		if (_serverTeleportPlayer == null || _playerLocalTeleport == null)
		{
			ResolveTeleportApi();
		}
		if (_server == null)
		{
			RefreshServer();
		}
		float safeX = requestedX;
		float safeY = 3f;
		float safeZ = requestedZ;
		string surfaceName;
		bool flag = TryFindSolidGroundNearIsland(requestedX, requestedZ, requiredSceneName, preferIslandLand, out safeX, out safeY, out safeZ, out surfaceName);
		if (!flag)
		{
			flag = TryFindSolidGroundNearIsland(requestedX, requestedZ, string.Empty, preferIslandLand, out safeX, out safeY, out safeZ, out surfaceName);
		}
		if (flag)
		{
			LogInfo((preferIslandLand ? "ANYWHERE island-land landing -> surface=" : "ANYWHERE ground-safe landing -> surface=") + surfaceName + " pos=(" + safeX.ToString("0.00") + ", " + safeY.ToString("0.00") + ", " + safeZ.ToString("0.00") + ")" + ((nearestIsland >= 0 && nearestIsland < IslandNames.Length) ? (" nearest=" + IslandNames[nearestIsland]) : string.Empty));
		}
		else
		{
			safeX = requestedX;
			safeY = 3f;
			safeZ = requestedZ;
			LogWarning("No solid ground at clicked map point; using exact X/Z fallback at Y=" + 3f.ToString("0.00") + ".");
		}
		object obj = CreateVector3(safeX, safeY, safeZ);
		if (obj == null)
		{
			LogWarning("Teleport failed: Vector3 could not be created.");
			return false;
		}
		if (_server != null && _serverTeleportPlayer != null)
		{
			try
			{
				_serverTeleportPlayer.Invoke(_server, new object[3] { _localPlayer, obj, yaw });
				LogInfo("Teleport route: Server.TeleportPlayer");
				return true;
			}
			catch (Exception ex)
			{
				LogWarning("Server.TeleportPlayer failed: " + ex.Message);
			}
		}
		if (_playerLocalTeleport != null)
		{
			try
			{
				_playerLocalTeleport.Invoke(_localPlayer, new object[3] { obj, yaw, true });
				LogInfo("Teleport route fallback: Player.LocalTeleport");
				return true;
			}
			catch (Exception ex2)
			{
				LogWarning("Player.LocalTeleport fallback failed: " + ex2.Message);
			}
		}
		LogWarning("Teleport failed: no usable native teleport route was available.");
		return false;
	}

	private void ResolvePhysicsApi()
	{
		if (_physicsType == null)
		{
			_physicsType = ResolveType("UnityEngine.Physics", "UnityEngine.PhysicsModule");
		}
		if (_vector3Type == null)
		{
			_vector3Type = ResolveType("UnityEngine.Vector3", "UnityEngine.CoreModule");
		}
		if (_raycastHitType == null)
		{
			_raycastHitType = ResolveType("UnityEngine.RaycastHit", "UnityEngine.PhysicsModule");
		}
		if (_queryTriggerInteractionType == null)
		{
			_queryTriggerInteractionType = ResolveType("UnityEngine.QueryTriggerInteraction", "UnityEngine.PhysicsModule");
		}
		if (_physicsType == null || _vector3Type == null)
		{
			return;
		}
		try
		{
			MethodInfo[] methods = _physicsType.GetMethods(BindingFlags.Static | BindingFlags.Public);
			MethodInfo methodInfo = null;
			foreach (MethodInfo methodInfo2 in methods)
			{
				if (methodInfo2.Name != "RaycastAll")
				{
					continue;
				}
				ParameterInfo[] parameters = methodInfo2.GetParameters();
				if (parameters.Length >= 3 && parameters.Length <= 5 && !(parameters[0].ParameterType != _vector3Type) && !(parameters[1].ParameterType != _vector3Type) && !(parameters[2].ParameterType != typeof(float)) && methodInfo2.ReturnType.IsArray)
				{
					if (parameters.Length == 3)
					{
						_physicsRaycastAll = methodInfo2;
						return;
					}
					if (methodInfo == null)
					{
						methodInfo = methodInfo2;
					}
				}
			}
			_physicsRaycastAll = methodInfo;
		}
		catch
		{
		}
	}

	private bool TryFindSolidGroundNearIsland(float baseX, float baseZ, string requiredSceneName, bool allowLowIslandGround, out float safeX, out float safeY, out float safeZ, out string surfaceName)
	{
		safeX = baseX;
		safeY = 1.5f;
		safeZ = baseZ;
		surfaceName = "none";
		if (_physicsRaycastAll == null)
		{
			ResolvePhysicsApi();
		}
		if (_physicsRaycastAll == null)
		{
			return false;
		}
		if (TryProbeSolidGround(baseX, baseZ, requiredSceneName, allowLowIslandGround, out var groundY, out var surfaceName2, out var lowSurfaceFound))
		{
			safeX = baseX;
			safeY = groundY + 1.75f;
			if (!allowLowIslandGround && safeY < 3f)
			{
				safeY = 3f;
			}
			safeZ = baseZ;
			surfaceName = surfaceName2;
			return true;
		}
		if (lowSurfaceFound)
		{
			LogInfo("Clicked point is over low/submerged ground; keeping exact X/Z and using the water-safe fallback height.");
			return false;
		}
		for (int i = 1; i < GroundProbeOffsetX.Length && i < GroundProbeOffsetZ.Length; i++)
		{
			float num = baseX + GroundProbeOffsetX[i];
			float num2 = baseZ + GroundProbeOffsetZ[i];
			if (TryProbeSolidGround(num, num2, requiredSceneName, allowLowIslandGround, out var groundY2, out var surfaceName3, out var _))
			{
				safeX = num;
				safeY = groundY2 + 1.75f;
				if (!allowLowIslandGround && safeY < 3f)
				{
					safeY = 3f;
				}
				safeZ = num2;
				surfaceName = surfaceName3;
				return true;
			}
		}
		return false;
	}

	private bool TryProbeSolidGround(float x, float z, string requiredSceneName, bool allowLowIslandGround, out float groundY, out string surfaceName, out bool lowSurfaceFound)
	{
		groundY = 0f;
		surfaceName = "none";
		lowSurfaceFound = false;
		if (_physicsRaycastAll == null)
		{
			return false;
		}
		try
		{
			object obj = CreateVector3(x, 250f, z);
			object obj2 = CreateVector3(0f, -1f, 0f);
			if (obj == null || obj2 == null)
			{
				return false;
			}
			ParameterInfo[] parameters = _physicsRaycastAll.GetParameters();
			object[] parameters2;
			if (parameters.Length == 3)
			{
				parameters2 = new object[3] { obj, obj2, 500f };
			}
			else if (parameters.Length == 4)
			{
				parameters2 = new object[4] { obj, obj2, 500f, -1 };
			}
			else
			{
				if (parameters.Length != 5)
				{
					return false;
				}
				object obj3 = null;
				if (_queryTriggerInteractionType != null)
				{
					try
					{
						obj3 = Enum.Parse(_queryTriggerInteractionType, "Ignore");
					}
					catch
					{
						obj3 = Enum.ToObject(_queryTriggerInteractionType, 1);
					}
				}
				parameters2 = new object[5] { obj, obj2, 500f, -1, obj3 };
			}
			if (!(_physicsRaycastAll.Invoke(null, parameters2) is Array { Length: not 0 } array))
			{
				return false;
			}
			bool flag = false;
			float num = float.MinValue;
			string text = "unknown";
			for (int i = 0; i < array.Length; i++)
			{
				object value = array.GetValue(i);
				if (value == null)
				{
					continue;
				}
				object obj5 = ReadPropertyValue(value, "collider");
				if (obj5 == null || ReadBoolProperty(obj5, "isTrigger", fallback: false))
				{
					continue;
				}
				string text2 = ReadStringProperty(obj5, "name");
				string text3 = text2;
				object obj6 = ReadPropertyValue(obj5, "transform");
				if (obj6 != null)
				{
					string text4 = ReadStringProperty(obj6, "name");
					if (!string.IsNullOrEmpty(text4))
					{
						text3 = text3 + "/" + text4;
					}
					object obj7 = ReadPropertyValue(obj6, "gameObject");
					if (obj7 != null)
					{
						string text5 = ReadStringProperty(obj7, "name");
						if (!string.IsNullOrEmpty(text5))
						{
							text3 = text3 + "/" + text5;
						}
					}
				}
				if (LooksLikeNonGroundCollider(text3))
				{
					continue;
				}
				string colliderSceneName = GetColliderSceneName(obj5);
				if (!string.IsNullOrEmpty(requiredSceneName) && !string.Equals(colliderSceneName, requiredSceneName, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				object obj8 = ReadPropertyValue(value, "normal");
				if (obj8 != null && TryReadVector3Y(obj8, out var y) && y < 0.45f)
				{
					continue;
				}
				object obj9 = ReadPropertyValue(value, "point");
				if (obj9 != null && TryReadVector3Y(obj9, out var y2))
				{
					if (!allowLowIslandGround && y2 + 1.75f < 3f)
					{
						lowSurfaceFound = true;
					}
					else if (!flag || y2 > num)
					{
						flag = true;
						num = y2;
						text = (string.IsNullOrEmpty(text2) ? "solid collider" : text2);
					}
				}
			}
			if (flag)
			{
				groundY = num;
				surfaceName = text;
				return true;
			}
		}
		catch (Exception ex)
		{
			LogWarning("Ground probe failed: " + ex.Message);
		}
		return false;
	}

	private static string GetColliderSceneName(object collider)
	{
		if (collider == null)
		{
			return string.Empty;
		}
		try
		{
			object obj = ReadPropertyValue(collider, "gameObject");
			if (obj == null)
			{
				object obj2 = ReadPropertyValue(collider, "transform");
				if (obj2 != null)
				{
					obj = ReadPropertyValue(obj2, "gameObject");
				}
			}
			if (obj == null)
			{
				return string.Empty;
			}
			object obj3 = ReadPropertyValue(obj, "scene");
			if (obj3 == null)
			{
				return string.Empty;
			}
			PropertyInfo property = obj3.GetType().GetProperty("name", BindingFlags.Instance | BindingFlags.Public);
			if (property == null)
			{
				return string.Empty;
			}
			object value = property.GetValue(obj3, null);
			return (value == null) ? string.Empty : value.ToString();
		}
		catch
		{
			return string.Empty;
		}
	}

	private static bool LooksLikeNonGroundCollider(string name)
	{
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		string text = name.ToLowerInvariant();
		string[] array = new string[29]
		{
			"water", "ocean", "sea", "trigger", "player", "boat", "item", "creature", "fish", "projectile",
			"bullet", "dynamicobject", "pickup", "radar", "camera", "volume", "killbox", "death", "hurt", "damage",
			"armupper", "armlower", "hand", "ragdoll", "character", "npc", "foot", "head", "hitbox"
		};
		for (int i = 0; i < array.Length; i++)
		{
			if (text.IndexOf(array[i], StringComparison.Ordinal) >= 0)
			{
				return true;
			}
		}
		return false;
	}

	private static object ReadPropertyValue(object instance, string propertyName)
	{
		if (instance == null)
		{
			return null;
		}
		try
		{
			PropertyInfo property = instance.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null)
			{
				return property.GetValue(instance, null);
			}
		}
		catch
		{
		}
		return null;
	}

	private static bool ReadBoolProperty(object instance, string propertyName, bool fallback)
	{
		try
		{
			object obj = ReadPropertyValue(instance, propertyName);
			if (obj != null)
			{
				return Convert.ToBoolean(obj);
			}
		}
		catch
		{
		}
		return fallback;
	}

	private static bool TryReadVector3XZ(object vector, out float x, out float z)
	{
		x = 0f;
		z = 0f;
		if (vector == null)
		{
			return false;
		}
		try
		{
			FieldInfo field = vector.GetType().GetField("x", BindingFlags.Instance | BindingFlags.Public);
			FieldInfo field2 = vector.GetType().GetField("z", BindingFlags.Instance | BindingFlags.Public);
			if (field != null && field2 != null)
			{
				x = Convert.ToSingle(field.GetValue(vector));
				z = Convert.ToSingle(field2.GetValue(vector));
				return true;
			}
			PropertyInfo property = vector.GetType().GetProperty("x", BindingFlags.Instance | BindingFlags.Public);
			PropertyInfo property2 = vector.GetType().GetProperty("z", BindingFlags.Instance | BindingFlags.Public);
			if (property != null && property2 != null)
			{
				x = Convert.ToSingle(property.GetValue(vector, null));
				z = Convert.ToSingle(property2.GetValue(vector, null));
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	private static bool TryReadVector3Y(object vector, out float y)
	{
		y = 0f;
		if (vector == null)
		{
			return false;
		}
		try
		{
			FieldInfo field = vector.GetType().GetField("y", BindingFlags.Instance | BindingFlags.Public);
			if (field != null)
			{
				y = Convert.ToSingle(field.GetValue(vector));
				return true;
			}
			PropertyInfo property = vector.GetType().GetProperty("y", BindingFlags.Instance | BindingFlags.Public);
			if (property != null)
			{
				y = Convert.ToSingle(property.GetValue(vector, null));
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	private object CreateVector3(float x, float y, float z)
	{
		if (_vector3Type == null)
		{
			_vector3Type = ResolveType("UnityEngine.Vector3", "UnityEngine.CoreModule");
		}
		if (_vector3Type == null)
		{
			return null;
		}
		try
		{
			return Activator.CreateInstance(_vector3Type, x, y, z);
		}
		catch
		{
			return null;
		}
	}

	private bool GetMouseButtonDown(int button)
	{
		if (_getMouseButtonDown == null)
		{
			return false;
		}
		try
		{
			return Convert.ToBoolean(_getMouseButtonDown.Invoke(null, new object[1] { button }));
		}
		catch
		{
			return false;
		}
	}

	private void DrawTexture(object rect, object texture)
	{
		if (_drawTexture4 != null && _scaleStretch != null)
		{
			_drawTexture4.Invoke(null, new object[4] { rect, texture, _scaleStretch, false });
		}
		else if (_drawTexture2 != null)
		{
			_drawTexture2.Invoke(null, new object[2] { rect, texture });
		}
	}

	private void DrawPlayerIndicator(float centerX, float centerY, float yawDegrees, float size)
	{
		int num = (int)Math.Round(size * 1.18f);
		if (num < 25)
		{
			num = 25;
		}
		if (num > 54)
		{
			num = 54;
		}
		BuildIndicatorStyles(num);
		float num2 = size * 1.2f;
		float num3 = size * 0.88f;
		float num4 = size * 0.34f;
		if (_label3 != null && _haloStyle != null && _ringStyle != null)
		{
			SetGuiColor(_whiteColor);
			_label3.Invoke(null, new object[3]
			{
				NewRect(centerX - num2 * 0.5f, centerY - num2 * 0.53f, num2, num2),
				"●",
				_haloStyle
			});
			_label3.Invoke(null, new object[3]
			{
				NewRect(centerX - num3 * 0.5f, centerY - num3 * 0.53f, num3, num3),
				"●",
				_ringStyle
			});
			_label3.Invoke(null, new object[3]
			{
				NewRect(centerX - num3 * 0.38f, centerY - num3 * 0.405f, num3 * 0.76f, num3 * 0.76f),
				"●",
				_haloStyle
			});
		}
		DrawRotatingPointer(centerX, centerY, yawDegrees, size);
		if (_label3 != null && _centerStyle != null)
		{
			SetGuiColor(_whiteColor);
			_label3.Invoke(null, new object[3]
			{
				NewRect(centerX - num4 * 0.5f, centerY - num4 * 0.54f, num4, num4),
				"●",
				_centerStyle
			});
		}
	}

	private void DrawRotatingPointer(float centerX, float centerY, float yawDegrees, float size)
	{
		float num = centerX - size * 0.5f;
		float num2 = centerY - size * 0.62f;
		float num3 = Math.Max(1f, size * 0.055f);
		object obj = null;
		bool flag = false;
		try
		{
			if (_guiMatrix != null && _rotateAroundPivot != null && _vector2Type != null)
			{
				obj = _guiMatrix.GetValue(null, null);
				object obj2 = Activator.CreateInstance(_vector2Type, centerX, centerY);
				_rotateAroundPivot.Invoke(null, new object[2]
				{
					NormalizeAngle(yawDegrees),
					obj2
				});
				flag = true;
			}
			string text = (flag ? "▲" : GetArrowGlyph(yawDegrees));
			if (_label3 != null && _indicatorStyle != null && _indicatorShadowStyle != null)
			{
				SetGuiColor(_whiteColor);
				_label3.Invoke(null, new object[3]
				{
					NewRect(num - num3, num2, size, size),
					text,
					_indicatorShadowStyle
				});
				_label3.Invoke(null, new object[3]
				{
					NewRect(num + num3, num2, size, size),
					text,
					_indicatorShadowStyle
				});
				_label3.Invoke(null, new object[3]
				{
					NewRect(num, num2 - num3, size, size),
					text,
					_indicatorShadowStyle
				});
				_label3.Invoke(null, new object[3]
				{
					NewRect(num, num2 + num3, size, size),
					text,
					_indicatorShadowStyle
				});
				_label3.Invoke(null, new object[3]
				{
					NewRect(num, num2, size, size),
					text,
					_indicatorStyle
				});
			}
			else
			{
				SetGuiColor(_blackColor);
				DrawLabel(NewRect(num - num3, num2, size, size), text);
				DrawLabel(NewRect(num + num3, num2, size, size), text);
				SetGuiColor(_yellowColor);
				DrawLabel(NewRect(num, num2, size, size), text);
			}
		}
		catch
		{
		}
		finally
		{
			if (flag && obj != null && _guiMatrix != null)
			{
				try
				{
					_guiMatrix.SetValue(null, obj, null);
				}
				catch
				{
				}
			}
		}
	}

	private void BuildIndicatorStyles(int fontSize)
	{
		if (_guiStyleType == null)
		{
			return;
		}
		try
		{
			if (_indicatorStyle == null)
			{
				_indicatorStyle = Activator.CreateInstance(_guiStyleType);
			}
			if (_indicatorShadowStyle == null)
			{
				_indicatorShadowStyle = Activator.CreateInstance(_guiStyleType);
			}
			if (_haloStyle == null)
			{
				_haloStyle = Activator.CreateInstance(_guiStyleType);
			}
			if (_ringStyle == null)
			{
				_ringStyle = Activator.CreateInstance(_guiStyleType);
			}
			if (_centerStyle == null)
			{
				_centerStyle = Activator.CreateInstance(_guiStyleType);
			}
			SetPropertyIfPresent(_indicatorStyle, "fontSize", fontSize);
			SetPropertyIfPresent(_indicatorShadowStyle, "fontSize", fontSize);
			SetPropertyIfPresent(_haloStyle, "fontSize", (int)Math.Round((float)fontSize * 1.12f));
			SetPropertyIfPresent(_ringStyle, "fontSize", (int)Math.Round((float)fontSize * 0.88f));
			SetPropertyIfPresent(_centerStyle, "fontSize", Math.Max(10, (int)Math.Round((float)fontSize * 0.34f)));
			if (_textAnchorType != null)
			{
				object value = Enum.Parse(_textAnchorType, "MiddleCenter");
				SetPropertyIfPresent(_indicatorStyle, "alignment", value);
				SetPropertyIfPresent(_indicatorShadowStyle, "alignment", value);
				SetPropertyIfPresent(_haloStyle, "alignment", value);
				SetPropertyIfPresent(_ringStyle, "alignment", value);
				SetPropertyIfPresent(_centerStyle, "alignment", value);
			}
			SetGuiStyleTextColor(_indicatorStyle, _yellowColor);
			SetGuiStyleTextColor(_indicatorShadowStyle, _blackColor);
			SetGuiStyleTextColor(_haloStyle, _haloColor);
			SetGuiStyleTextColor(_ringStyle, _softGoldColor);
			SetGuiStyleTextColor(_centerStyle, _centerColor);
		}
		catch
		{
		}
	}

	private void SetGuiStyleTextColor(object style, object color)
	{
		if (style == null || color == null)
		{
			return;
		}
		try
		{
			PropertyInfo property = style.GetType().GetProperty("normal", BindingFlags.Instance | BindingFlags.Public);
			if (property == null)
			{
				return;
			}
			object value = property.GetValue(style, null);
			if (value != null)
			{
				PropertyInfo property2 = value.GetType().GetProperty("textColor", BindingFlags.Instance | BindingFlags.Public);
				if (property2 != null && property2.CanWrite)
				{
					property2.SetValue(value, color, null);
				}
			}
		}
		catch
		{
		}
	}

	private string GetArrowGlyph(float yawDegrees)
	{
		float num = NormalizeAngle(yawDegrees);
		return ((int)Math.Round((double)num / 45.0) % 8) switch
		{
			0 => "▲", 
			1 => "◥", 
			2 => "▶", 
			3 => "◢", 
			4 => "▼", 
			5 => "◣", 
			6 => "◀", 
			_ => "◤", 
		};
	}

	private void DrawLabel(object rect, string text)
	{
		if (_label2 != null)
		{
			_label2.Invoke(null, new object[2] { rect, text });
		}
	}

	private void DrawSolidRect(float x, float y, float w, float h, object color)
	{
		if (_whiteTexture != null && !(_drawTexture2 == null))
		{
			object guiColor = GetGuiColor();
			SetGuiColor(color);
			_drawTexture2.Invoke(null, new object[2]
			{
				NewRect(x, y, w, h),
				_whiteTexture
			});
			SetGuiColor(guiColor);
		}
	}

	private void GetNavigationState(out float x, out float z, out float yawDegrees)
	{
		x = 0f;
		z = 0f;
		yawDegrees = 0f;
		if (_localPlayerTransform == null || _frameCounter % 30 == 0)
		{
			RefreshLocalPlayer();
		}
		object localPlayerTransform = _localPlayerTransform;
		if (localPlayerTransform == null)
		{
			return;
		}
		try
		{
			PropertyInfo property = localPlayerTransform.GetType().GetProperty("position", BindingFlags.Instance | BindingFlags.Public);
			if (property != null)
			{
				object value = property.GetValue(localPlayerTransform, null);
				if (value != null)
				{
					FieldInfo field = value.GetType().GetField("x", BindingFlags.Instance | BindingFlags.Public);
					FieldInfo field2 = value.GetType().GetField("z", BindingFlags.Instance | BindingFlags.Public);
					if (field != null)
					{
						x = Convert.ToSingle(field.GetValue(value));
					}
					if (field2 != null)
					{
						z = Convert.ToSingle(field2.GetValue(value));
					}
				}
			}
			if (TryGetLivePlayerLookYaw(out var yawDegrees2))
			{
				yawDegrees = yawDegrees2;
				return;
			}
			if (TryGetPlayerCamObjectYaw(out yawDegrees2))
			{
				yawDegrees = yawDegrees2;
				return;
			}
			if (TryGetCameraYaw(out yawDegrees2))
			{
				yawDegrees = yawDegrees2;
				return;
			}
			yawDegrees = ReadTransformYaw(localPlayerTransform);
			_lastYawSource = "LocalPlayer.Transform";
		}
		catch
		{
		}
	}

	private bool TryGetLivePlayerLookYaw(out float yawDegrees)
	{
		yawDegrees = 0f;
		if (_localPlayer == null || _playerType == null)
		{
			return false;
		}
		try
		{
			if (_playerCameraField == null)
			{
				_playerCameraField = _playerType.GetField("_camera", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_playerCameraField == null)
			{
				return false;
			}
			object value = _playerCameraField.GetValue(_localPlayer);
			if (value == null)
			{
				return false;
			}
			if (_playerCameraRotField == null || _playerCameraRotField.DeclaringType != value.GetType())
			{
				_playerCameraRotField = value.GetType().GetField("_rot", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_playerCameraRotField == null)
			{
				return false;
			}
			object value2 = _playerCameraRotField.GetValue(value);
			if (value2 == null)
			{
				return false;
			}
			FieldInfo field = value2.GetType().GetField("y", BindingFlags.Instance | BindingFlags.Public);
			if (field == null)
			{
				return false;
			}
			yawDegrees = NormalizeAngle(Convert.ToSingle(field.GetValue(value2)));
			_lastYawSource = "PlayerCamera._rot.y";
			return true;
		}
		catch
		{
			return false;
		}
	}

	private bool TryGetPlayerCamObjectYaw(out float yawDegrees)
	{
		yawDegrees = 0f;
		if (_localPlayer == null || _playerType == null)
		{
			return false;
		}
		try
		{
			if (_playerCamObjectField == null)
			{
				_playerCamObjectField = _playerType.GetField("<CamObject>k__BackingField", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_playerCamObjectField == null)
			{
				return false;
			}
			object value = _playerCamObjectField.GetValue(_localPlayer);
			if (value == null)
			{
				return false;
			}
			yawDegrees = NormalizeAngle(ReadTransformYaw(value));
			_lastYawSource = "Player.CamObject";
			return true;
		}
		catch
		{
			return false;
		}
	}

	private bool TryGetCameraYaw(out float yawDegrees)
	{
		yawDegrees = 0f;
		if (_camera == null)
		{
			return false;
		}
		try
		{
			PropertyInfo property = _camera.GetType().GetProperty("transform", BindingFlags.Instance | BindingFlags.Public);
			if (property == null)
			{
				return false;
			}
			object value = property.GetValue(_camera, null);
			if (value == null)
			{
				return false;
			}
			yawDegrees = ReadTransformYaw(value);
			_lastYawSource = "Camera.main";
			return true;
		}
		catch
		{
			return false;
		}
	}

	private float ReadTransformYaw(object transform)
	{
		if (transform == null)
		{
			return 0f;
		}
		try
		{
			PropertyInfo property = transform.GetType().GetProperty("eulerAngles", BindingFlags.Instance | BindingFlags.Public);
			if (property == null)
			{
				return 0f;
			}
			object value = property.GetValue(transform, null);
			if (value == null)
			{
				return 0f;
			}
			FieldInfo field = value.GetType().GetField("y", BindingFlags.Instance | BindingFlags.Public);
			if (field != null)
			{
				return Convert.ToSingle(field.GetValue(value));
			}
		}
		catch
		{
		}
		return 0f;
	}

	private void RefreshLocalPlayer()
	{
		if (_playerType == null)
		{
			_playerType = ResolveType("Player", "Assembly-CSharp");
		}
		if (_playerType == null)
		{
			return;
		}
		try
		{
			Array array = FindUnityObjectsOfType(_playerType);
			if (array == null || array.Length == 0)
			{
				return;
			}
			object obj = null;
			object obj2 = null;
			for (int i = 0; i < array.Length; i++)
			{
				object value = array.GetValue(i);
				if (value == null)
				{
					continue;
				}
				object playerNavigationTransform = GetPlayerNavigationTransform(value);
				if (playerNavigationTransform != null)
				{
					string text = ReadStringProperty(value, "name");
					if (text == "PlayerHolder(Clone)")
					{
						obj = value;
						obj2 = playerNavigationTransform;
						break;
					}
					if (obj == null)
					{
						obj = value;
						obj2 = playerNavigationTransform;
					}
				}
			}
			if (obj != null && obj2 != null)
			{
				bool flag = !object.ReferenceEquals(_localPlayer, obj);
				_localPlayer = obj;
				_localPlayerTransform = obj2;
				if (flag)
				{
					LogInfo("Player tracker locked to live PlayerHolder(Clone) Transform.");
				}
			}
		}
		catch
		{
		}
	}

	private object GetPlayerNavigationTransform(object player)
	{
		if (player == null)
		{
			return null;
		}
		try
		{
			if (_playerTransformField == null)
			{
				_playerTransformField = _playerType.GetField("<Transform>k__BackingField", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_playerTransformField != null)
			{
				object value = _playerTransformField.GetValue(player);
				if (value != null)
				{
					return value;
				}
			}
			PropertyInfo property = _playerType.GetProperty("Transform", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null)
			{
				object value2 = property.GetValue(player, null);
				if (value2 != null)
				{
					return value2;
				}
			}
		}
		catch
		{
		}
		return null;
	}

	private Array FindUnityObjectsOfType(Type wantedType)
	{
		try
		{
			Type type = ResolveType("UnityEngine.Object", "UnityEngine.CoreModule");
			if (type != null)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.Name != "FindObjectsOfType")
					{
						continue;
					}
					ParameterInfo[] parameters = methodInfo.GetParameters();
					object obj = null;
					if (parameters.Length == 1 && parameters[0].ParameterType == typeof(Type))
					{
						obj = methodInfo.Invoke(null, new object[1] { wantedType });
					}
					else
					{
						if (parameters.Length != 2 || !(parameters[0].ParameterType == typeof(Type)) || !(parameters[1].ParameterType == typeof(bool)))
						{
							continue;
						}
						obj = methodInfo.Invoke(null, new object[2] { wantedType, true });
					}
					if (obj is Array { Length: >0 } array)
					{
						return array;
					}
				}
			}
		}
		catch
		{
		}
		try
		{
			Type type2 = ResolveType("UnityEngine.Resources", "UnityEngine.CoreModule");
			if (type2 != null)
			{
				MethodInfo method = type2.GetMethod("FindObjectsOfTypeAll", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(Type) }, null);
				if (method != null)
				{
					return method.Invoke(null, new object[1] { wantedType }) as Array;
				}
			}
		}
		catch
		{
		}
		return null;
	}

	private void OpenFullMap()
	{
		if (!_fullMapOpen)
		{
			SaveCursorState();
			_fullMapOpen = true;
			RefreshPlayerCamera();
			RefreshLocalPlayer();
			GetNavigationState(out var x, out var z, out var yawDegrees);
			_frozenMapYaw = NormalizeAngle(yawDegrees);
			_frozenMapYawValid = true;
			string lastYawSource = _lastYawSource;
			WorldToMapNormalizedAuto(x, z, out var u, out var screenV, out var mappedIsland);
			LogInfo("Map tracker world position: X=" + x.ToString("0.00") + " Z=" + z.ToString("0.00") + " frozenYaw=" + _frozenMapYaw.ToString("0.0") + " source=" + lastYawSource + " -> map=(" + u.ToString("0.000") + "," + screenV.ToString("0.000") + ")" + ((mappedIsland >= 0) ? (" lockedBounds=" + IslandNames[mappedIsland]) : " globalFallback"));
			TryTogglePlayerMouse(unlock: true);
			DisablePlayerCameraForMap();
			ForceCursorUnlocked();
		}
	}

	private void CloseFullMap()
	{
		if (_fullMapOpen)
		{
			_fullMapOpen = false;
			_frozenMapYawValid = false;
			RestorePlayerCameraAfterMap();
			TryTogglePlayerMouse(unlock: false);
			RestoreCursorState();
		}
	}

	private void RefreshPlayerCamera()
	{
		if (_playerCameraType == null)
		{
			_playerCameraType = ResolveType("PlayerCamera", "Assembly-CSharp");
		}
		if (_playerCameraType == null)
		{
			return;
		}
		object obj = null;
		if (_camera != null)
		{
			try
			{
				MethodInfo[] methods = _camera.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public);
				for (int i = 0; i < methods.Length; i++)
				{
					if (obj != null)
					{
						break;
					}
					MethodInfo methodInfo = methods[i];
					if (!(methodInfo.Name != "GetComponentInParent"))
					{
						ParameterInfo[] parameters = methodInfo.GetParameters();
						if (parameters.Length == 1 && parameters[0].ParameterType == typeof(Type))
						{
							obj = methodInfo.Invoke(_camera, new object[1] { _playerCameraType });
						}
						else if (parameters.Length == 2 && parameters[0].ParameterType == typeof(Type) && parameters[1].ParameterType == typeof(bool))
						{
							obj = methodInfo.Invoke(_camera, new object[2] { _playerCameraType, true });
						}
					}
				}
			}
			catch
			{
			}
		}
		if (obj == null)
		{
			obj = FindUnityObjectOfType(_playerCameraType);
		}
		if (obj != null)
		{
			_playerCamera = obj;
			_toggleMouse = _playerCameraType.GetMethod("ToggleMouse", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(bool) }, null);
			_playerCameraEnabled = _playerCameraType.GetProperty("enabled", BindingFlags.Instance | BindingFlags.Public);
		}
	}

	private object FindUnityObjectOfType(Type wantedType)
	{
		try
		{
			Type type = ResolveType("UnityEngine.Object", "UnityEngine.CoreModule");
			if (type == null)
			{
				return null;
			}
			MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name != "FindObjectsOfType")
				{
					continue;
				}
				ParameterInfo[] parameters = methodInfo.GetParameters();
				object obj = null;
				if (parameters.Length == 1 && parameters[0].ParameterType == typeof(Type))
				{
					obj = methodInfo.Invoke(null, new object[1] { wantedType });
				}
				else
				{
					if (parameters.Length != 2 || !(parameters[0].ParameterType == typeof(Type)) || !(parameters[1].ParameterType == typeof(bool)))
					{
						continue;
					}
					obj = methodInfo.Invoke(null, new object[2] { wantedType, true });
				}
				if (!(obj is Array { Length: >0 } array))
				{
					continue;
				}
				for (int j = 0; j < array.Length; j++)
				{
					object value = array.GetValue(j);
					if (value != null)
					{
						return value;
					}
				}
			}
		}
		catch
		{
		}
		try
		{
			Type type2 = ResolveType("UnityEngine.Resources", "UnityEngine.CoreModule");
			if (type2 != null)
			{
				MethodInfo method = type2.GetMethod("FindObjectsOfTypeAll", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(Type) }, null);
				if (method != null && method.Invoke(null, new object[1] { wantedType }) is Array { Length: >0 } array2)
				{
					for (int k = 0; k < array2.Length; k++)
					{
						object value2 = array2.GetValue(k);
						if (value2 != null)
						{
							return value2;
						}
					}
				}
			}
		}
		catch
		{
		}
		return null;
	}

	private void SaveCursorState()
	{
		try
		{
			if (_cursorVisible != null)
			{
				_oldCursorVisible = Convert.ToBoolean(_cursorVisible.GetValue(null, null));
			}
			if (_cursorLockState != null)
			{
				_oldCursorLock = _cursorLockState.GetValue(null, null);
			}
		}
		catch
		{
		}
	}

	private void ForceCursorUnlocked()
	{
		try
		{
			if (_cursorVisible != null)
			{
				_cursorVisible.SetValue(null, true, null);
			}
			if (_cursorLockState != null && _cursorNone != null)
			{
				_cursorLockState.SetValue(null, _cursorNone, null);
			}
		}
		catch
		{
		}
	}

	private void RestoreCursorState()
	{
		try
		{
			if (_cursorVisible != null)
			{
				_cursorVisible.SetValue(null, _oldCursorVisible, null);
			}
			if (_cursorLockState != null && _oldCursorLock != null)
			{
				_cursorLockState.SetValue(null, _oldCursorLock, null);
			}
		}
		catch
		{
		}
	}

	private void DisablePlayerCameraForMap()
	{
		try
		{
			if (_playerCamera == null || _playerCameraEnabled == null)
			{
				RefreshPlayerCamera();
			}
			if (_playerCamera == null || _playerCameraEnabled == null)
			{
				LogWarning("PlayerCamera was not found; cursor unlocked but hard camera lock is unavailable.");
				return;
			}
			_oldPlayerCameraEnabled = Convert.ToBoolean(_playerCameraEnabled.GetValue(_playerCamera, null));
			_playerCameraEnabled.SetValue(_playerCamera, false, null);
			_playerCameraDisabledByMap = true;
			LogInfo("Map camera lock: PlayerCamera disabled.");
		}
		catch (Exception ex)
		{
			LogWarning("Could not disable PlayerCamera: " + ex.Message);
		}
	}

	private void RestorePlayerCameraAfterMap()
	{
		if (!_playerCameraDisabledByMap)
		{
			return;
		}
		try
		{
			if (_playerCamera != null && _playerCameraEnabled != null)
			{
				_playerCameraEnabled.SetValue(_playerCamera, _oldPlayerCameraEnabled, null);
			}
		}
		catch
		{
		}
		_playerCameraDisabledByMap = false;
	}

	private bool TryTogglePlayerMouse(bool unlock)
	{
		try
		{
			if (_playerCamera == null || _toggleMouse == null)
			{
				RefreshPlayerCamera();
			}
			if (_playerCamera == null || _toggleMouse == null)
			{
				return false;
			}
			_toggleMouse.Invoke(_playerCamera, new object[1] { unlock });
			return true;
		}
		catch
		{
			return false;
		}
	}

	private bool GetKeyDown(object key)
	{
		if (_getKeyDown == null || key == null)
		{
			return false;
		}
		try
		{
			return Convert.ToBoolean(_getKeyDown.Invoke(null, new object[1] { key }));
		}
		catch
		{
			return false;
		}
	}

	private int GetScreenWidth()
	{
		try
		{
			return Convert.ToInt32(_screenWidth.GetValue(null, null));
		}
		catch
		{
			return 1920;
		}
	}

	private int GetScreenHeight()
	{
		try
		{
			return Convert.ToInt32(_screenHeight.GetValue(null, null));
		}
		catch
		{
			return 1080;
		}
	}

	private object NewRect(float x, float y, float w, float h)
	{
		return Activator.CreateInstance(_rectType, x, y, w, h);
	}

	private object NewColor(float r, float g, float b, float a)
	{
		return Activator.CreateInstance(_colorType, r, g, b, a);
	}

	private object GetGuiColor()
	{
		try
		{
			return (_guiColor == null) ? _whiteColor : _guiColor.GetValue(null, null);
		}
		catch
		{
			return _whiteColor;
		}
	}

	private void SetGuiColor(object color)
	{
		if (_guiColor == null || color == null)
		{
			return;
		}
		try
		{
			_guiColor.SetValue(null, color, null);
		}
		catch
		{
		}
	}

	private static void SetPropertyIfPresent(object instance, string propertyName, object value)
	{
		if (instance == null)
		{
			return;
		}
		try
		{
			PropertyInfo property = instance.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public);
			if (property != null && property.CanWrite)
			{
				property.SetValue(instance, value, null);
			}
		}
		catch
		{
		}
	}

	private static string ReadStringProperty(object instance, string propertyName)
	{
		try
		{
			PropertyInfo property = instance.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public);
			if (property != null)
			{
				object value = property.GetValue(instance, null);
				return (value == null) ? string.Empty : value.ToString();
			}
		}
		catch
		{
		}
		return string.Empty;
	}

	private static int ReadIntProperty(object instance, string propertyName, int fallback)
	{
		try
		{
			PropertyInfo property = instance.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public);
			if (property != null)
			{
				return Convert.ToInt32(property.GetValue(instance, null));
			}
		}
		catch
		{
		}
		return fallback;
	}

	private static void WorldToMapNormalized(float worldX, float worldZ, out float u, out float screenV)
	{
		u = 0.0006040856f * worldX + 0.5680561f;
		screenV = -0.0005951446f * worldZ + 0.4647192f;
		u = Clamp(u, 0.045f, 0.955f);
		screenV = Clamp(screenV, 0.04f, 0.955f);
	}

	private static void MapNormalizedToWorld(float u, float screenV, out float worldX, out float worldZ)
	{
		worldX = (u - 0.5680561f) / 0.0006040856f;
		worldZ = (screenV - 0.4647192f) / -0.0005951446f;
	}

	private static float NormalizeAngle(float degrees)
	{
		while (degrees < 0f)
		{
			degrees += 360f;
		}
		while (degrees >= 360f)
		{
			degrees -= 360f;
		}
		return degrees;
	}

	private static float InverseLerp(float a, float b, float value)
	{
		if (Math.Abs(b - a) < 0.0001f)
		{
			return 0.5f;
		}
		return Clamp((value - a) / (b - a), 0f, 1f);
	}

	private static float Clamp(float value, float min, float max)
	{
		if (value < min)
		{
			return min;
		}
		if (value > max)
		{
			return max;
		}
		return value;
	}

	private static MethodInfo FindStaticMethod(Type type, string name, Type[] parameterTypes)
	{
		if (type == null)
		{
			return null;
		}
		try
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
		}
		catch
		{
			return null;
		}
	}

	private static Type ResolveType(string fullName, params string[] assemblyNames)
	{
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		for (int i = 0; i < assemblies.Length; i++)
		{
			try
			{
				Type type = assemblies[i].GetType(fullName, throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			catch
			{
			}
		}
		if (assemblyNames != null)
		{
			for (int i = 0; i < assemblyNames.Length; i++)
			{
				try
				{
					Assembly assembly = Assembly.Load(assemblyNames[i]);
					Type type2 = assembly.GetType(fullName, throwOnError: false);
					if (type2 != null)
					{
						return type2;
					}
				}
				catch
				{
				}
			}
		}
		return null;
	}
}