using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using UnityEngine;
using UnityEngine.Bindings;
using UnityEngine.Internal;
using UnityEngine.Scripting;

[assembly: InternalsVisibleTo("UnityEngine.UnityWebRequestAudioModule")]
[assembly: InternalsVisibleTo("UnityEngine.UnityWebRequestTextureModule")]
[assembly: InternalsVisibleTo("UnityEngine.UnityWebRequestWWWModule")]
[assembly: InternalsVisibleTo("UnityEngine.VFXModule")]
[assembly: InternalsVisibleTo("UnityEngine.XRModule")]
[assembly: InternalsVisibleTo("UnityEngine.VRModule")]
[assembly: InternalsVisibleTo("UnityEngine.VehiclesModule")]
[assembly: InternalsVisibleTo("UnityEngine.VideoModule")]
[assembly: InternalsVisibleTo("UnityEngine.VirtualTexturingModule")]
[assembly: InternalsVisibleTo("UnityEngine.WindModule")]
[assembly: InternalsVisibleTo("UnityEngine.Networking")]
[assembly: InternalsVisibleTo("UnityEngine.Cloud")]
[assembly: InternalsVisibleTo("UnityEngine.Cloud.Service")]
[assembly: InternalsVisibleTo("Unity.Analytics")]
[assembly: InternalsVisibleTo("UnityEngine.Analytics")]
[assembly: InternalsVisibleTo("UnityEngine.UnityAnalyticsCommon")]
[assembly: InternalsVisibleTo("UnityEngine.Advertisements")]
[assembly: InternalsVisibleTo("UnityEngine.Purchasing")]
[assembly: InternalsVisibleTo("UnityEngine.TestRunner")]
[assembly: InternalsVisibleTo("Unity.Automation")]
[assembly: InternalsVisibleTo("Unity.Burst")]
[assembly: InternalsVisibleTo("Unity.Burst.Editor")]
[assembly: InternalsVisibleTo("Unity.DeploymentTests.Services")]
[assembly: InternalsVisibleTo("Unity.IntegrationTests")]
[assembly: InternalsVisibleTo("Unity.IntegrationTests.UnityAnalytics")]
[assembly: InternalsVisibleTo("Unity.IntegrationTests.Timeline")]
[assembly: InternalsVisibleTo("Unity.IntegrationTests.Framework")]
[assembly: InternalsVisibleTo("UnityEngine.UnityWebRequestAssetBundleModule")]
[assembly: InternalsVisibleTo("Unity.RuntimeTests")]
[assembly: InternalsVisibleTo("UnityEngine.UnityTestProtocolModule")]
[assembly: InternalsVisibleTo("UnityEngine.UmbraModule")]
[assembly: InternalsVisibleTo("UnityEngine.ImageConversionModule")]
[assembly: InternalsVisibleTo("UnityEngine.GameCenterModule")]
[assembly: InternalsVisibleTo("UnityEngine.GridModule")]
[assembly: InternalsVisibleTo("UnityEngine.TextRenderingModule")]
[assembly: InternalsVisibleTo("UnityEngine.InputLegacyModule")]
[assembly: InternalsVisibleTo("UnityEngine.TextCoreFontEngineModule")]
[assembly: InternalsVisibleTo("UnityEngine.TextCoreTextEngineModule")]
[assembly: InternalsVisibleTo("UnityEngine.IMGUIModule")]
[assembly: InternalsVisibleTo("UnityEngine.LocalizationModule")]
[assembly: InternalsVisibleTo("UnityEngine.NVIDIAModule")]
[assembly: InternalsVisibleTo("UnityEngine.ParticleSystemModule")]
[assembly: InternalsVisibleTo("UnityEngine.PerformanceReportingModule")]
[assembly: InternalsVisibleTo("UnityEngine.Physics2DModule")]
[assembly: InternalsVisibleTo("UnityEngine.ProfilerModule")]
[assembly: InternalsVisibleTo("UnityEngine.PropertiesModule")]
[assembly: InternalsVisibleTo("UnityEngine.RuntimeInitializeOnLoadManagerInitializerModule")]
[assembly: InternalsVisibleTo("UnityEngine.ScreenCaptureModule")]
[assembly: InternalsVisibleTo("UnityEngine.SpriteMaskModule")]
[assembly: InternalsVisibleTo("UnityEngine.SpriteShapeModule")]
[assembly: InternalsVisibleTo("UnityEngine.StreamingModule")]
[assembly: InternalsVisibleTo("UnityEngine.SubstanceModule")]
[assembly: InternalsVisibleTo("UnityEngine.SubsystemsModule")]
[assembly: InternalsVisibleTo("UnityEngine.TerrainModule")]
[assembly: InternalsVisibleTo("UnityEngine.TerrainPhysicsModule")]
[assembly: InternalsVisibleTo("UnityEngine.TilemapModule")]
[assembly: InternalsVisibleTo("UnityEngine.UIModule")]
[assembly: InternalsVisibleTo("UnityEngine.UIElementsModule")]
[assembly: InternalsVisibleTo("UnityEngine.UnityCurlModule")]
[assembly: InternalsVisibleTo("Unity.RuntimeTests.Framework")]
[assembly: InternalsVisibleTo("Unity.RuntimeTests.Framework.Tests")]
[assembly: InternalsVisibleTo("Unity.PerformanceTests.RuntimeTestRunner.Tests")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.004")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.005")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.006")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.007")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.008")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.009")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.010")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.011")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.012")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.013")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.014")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.015")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.016")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.017")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.018")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.019")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.020")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.021")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.022")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.023")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.024")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridgeDev.001")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridgeDev.002")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridgeDev.003")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridgeDev.004")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridgeDev.005")]
[assembly: InternalsVisibleTo("Unity.Subsystem.Registration")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.003")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.002")]
[assembly: InternalsVisibleTo("Unity.InternalAPIEngineBridge.001")]
[assembly: InternalsVisibleTo("UnityEngine.Core.Runtime.Tests")]
[assembly: InternalsVisibleTo("Unity.RuntimeTests.AllIn1Runner")]
[assembly: InternalsVisibleTo("Unity.Timeline")]
[assembly: InternalsVisibleTo("Assembly-CSharp-testable")]
[assembly: InternalsVisibleTo("Assembly-CSharp-firstpass-testable")]
[assembly: InternalsVisibleTo("UnityEngine.SpatialTracking")]
[assembly: InternalsVisibleTo("GoogleAR.UnityNative")]
[assembly: InternalsVisibleTo("Unity.WindowsMRAutomation")]
[assembly: InternalsVisibleTo("Unity.2D.Sprite.Editor")]
[assembly: InternalsVisibleTo("Unity.2D.Sprite.EditorTests")]
[assembly: InternalsVisibleTo("Unity.UI.Builder.Editor")]
[assembly: InternalsVisibleTo("UnityEditor.UIBuilderModule")]
[assembly: InternalsVisibleTo("Unity.UI.Builder.EditorTests")]
[assembly: InternalsVisibleTo("Unity.UIElements")]
[assembly: InternalsVisibleTo("UnityEngine.GIModule")]
[assembly: InternalsVisibleTo("UnityEngine.UIElementsGameObjectsModule")]
[assembly: InternalsVisibleTo("Unity.UIElements.PlayModeTests")]
[assembly: InternalsVisibleTo("UnityEngine.UIElements.Tests")]
[assembly: InternalsVisibleTo("Unity.UIElements.EditorTests")]
[assembly: InternalsVisibleTo("UnityEngine.UI")]
[assembly: InternalsVisibleTo("Unity.Networking.Transport")]
[assembly: InternalsVisibleTo("Unity.ucg.QoS")]
[assembly: InternalsVisibleTo("Unity.Services.QoS")]
[assembly: InternalsVisibleTo("Unity.Logging")]
[assembly: InternalsVisibleTo("Unity.Entities")]
[assembly: InternalsVisibleTo("Unity.Entities.Tests")]
[assembly: InternalsVisibleTo("Unity.Collections")]
[assembly: InternalsVisibleTo("Unity.Runtime")]
[assembly: InternalsVisibleTo("Unity.Core")]
[assembly: InternalsVisibleTo("Unity.UIElements.Editor")]
[assembly: InternalsVisibleTo("UnityEngine.DirectorModule")]
[assembly: InternalsVisibleTo("UnityEngine.DSPGraphModule")]
[assembly: InternalsVisibleTo("UnityEngine.CrashReportingModule")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: InternalsVisibleTo("UnityEngine")]
[assembly: InternalsVisibleTo("UnityEngine.SharedInternalsModule")]
[assembly: InternalsVisibleTo("UnityEngine.CoreModule")]
[assembly: InternalsVisibleTo("UnityEngine.AIModule")]
[assembly: InternalsVisibleTo("UnityEngine.PhysicsModule")]
[assembly: InternalsVisibleTo("UnityEngine.JSONSerializeModule")]
[assembly: InternalsVisibleTo("UnityEngine.InputModule")]
[assembly: InternalsVisibleTo("UnityEngine.ARModule")]
[assembly: InternalsVisibleTo("UnityEngine.AccessibilityModule")]
[assembly: InternalsVisibleTo("UnityEngine.AndroidJNIModule")]
[assembly: InternalsVisibleTo("UnityEngine.AnimationModule")]
[assembly: InternalsVisibleTo("UnityEngine.HotReloadModule")]
[assembly: InternalsVisibleTo("UnityEngine.AssetBundleModule")]
[assembly: InternalsVisibleTo("UnityEngine.AudioModule")]
[assembly: InternalsVisibleTo("UnityEngine.ClothModule")]
[assembly: InternalsVisibleTo("UnityEngine.ClusterInputModule")]
[assembly: InternalsVisibleTo("UnityEngine.ClusterRendererModule")]
[assembly: InternalsVisibleTo("UnityEngine.ContentLoadModule")]
[assembly: InternalsVisibleTo("UnityEngine.TLSModule")]
[assembly: InternalsVisibleTo("UnityEngine.UnityConnectModule")]
[assembly: InternalsVisibleTo("UnityEngine.UnityAnalyticsCommonModule")]
[assembly: InternalsVisibleTo("UnityEngine.UnityWebRequestModule")]
[assembly: InternalsVisibleTo("UnityEngine.UnityAnalyticsModule")]
[assembly: CompilationRelaxations(8)]
[assembly: UnityEngineModuleAssembly]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace UnityEngine
{
	public enum TouchPhase
	{
		Began,
		Moved,
		Stationary,
		Ended,
		Canceled
	}
	public enum IMECompositionMode
	{
		Auto,
		On,
		Off
	}
	public enum TouchType
	{
		Direct,
		Indirect,
		Stylus
	}
	[NativeHeader("Runtime/Input/InputBindings.h")]
	public struct Touch
	{
		private int m_FingerId;

		private Vector2 m_Position;

		private Vector2 m_RawPosition;

		private Vector2 m_PositionDelta;

		private float m_TimeDelta;

		private int m_TapCount;

		private TouchPhase m_Phase;

		private TouchType m_Type;

		private float m_Pressure;

		private float m_maximumPossiblePressure;

		private float m_Radius;

		private float m_RadiusVariance;

		private float m_AltitudeAngle;

		private float m_AzimuthAngle;

		public int fingerId
		{
			get
			{
				return m_FingerId;
			}
			set
			{
				m_FingerId = value;
			}
		}

		public Vector2 position
		{
			get
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return m_Position;
			}
			set
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				m_Position = value;
			}
		}

		public Vector2 rawPosition
		{
			get
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return m_RawPosition;
			}
			set
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				m_RawPosition = value;
			}
		}

		public Vector2 deltaPosition
		{
			get
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return m_PositionDelta;
			}
			set
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				m_PositionDelta = value;
			}
		}

		public float deltaTime
		{
			get
			{
				return m_TimeDelta;
			}
			set
			{
				m_TimeDelta = value;
			}
		}

		public int tapCount
		{
			get
			{
				return m_TapCount;
			}
			set
			{
				m_TapCount = value;
			}
		}

		public TouchPhase phase
		{
			get
			{
				return m_Phase;
			}
			set
			{
				m_Phase = value;
			}
		}

		public float pressure
		{
			get
			{
				return m_Pressure;
			}
			set
			{
				m_Pressure = value;
			}
		}

		public float maximumPossiblePressure
		{
			get
			{
				return m_maximumPossiblePressure;
			}
			set
			{
				m_maximumPossiblePressure = value;
			}
		}

		public TouchType type
		{
			get
			{
				return m_Type;
			}
			set
			{
				m_Type = value;
			}
		}

		public float altitudeAngle
		{
			get
			{
				return m_AltitudeAngle;
			}
			set
			{
				m_AltitudeAngle = value;
			}
		}

		public float azimuthAngle
		{
			get
			{
				return m_AzimuthAngle;
			}
			set
			{
				m_AzimuthAngle = value;
			}
		}

		public float radius
		{
			get
			{
				return m_Radius;
			}
			set
			{
				m_Radius = value;
			}
		}

		public float radiusVariance
		{
			get
			{
				return m_RadiusVariance;
			}
			set
			{
				m_RadiusVariance = value;
			}
		}
	}
	[Flags]
	public enum PenStatus
	{
		None = 0,
		Contact = 1,
		Barrel = 2,
		Inverted = 4,
		Eraser = 8
	}
	public enum PenEventType
	{
		NoContact,
		PenDown,
		PenUp
	}
	public struct PenData
	{
		public Vector2 position;

		public Vector2 tilt;

		public PenStatus penStatus;

		public float twist;

		public float pressure;

		public PenEventType contactType;

		public Vector2 deltaPos;
	}
	public enum DeviceOrientation
	{
		Unknown,
		Portrait,
		PortraitUpsideDown,
		LandscapeLeft,
		LandscapeRight,
		FaceUp,
		FaceDown
	}
	public struct AccelerationEvent
	{
		internal float x;

		internal float y;

		internal float z;

		internal float m_TimeDelta;

		public Vector3 acceleration => new Vector3(x, y, z);

		public float deltaTime => m_TimeDelta;
	}
	[NativeHeader("Runtime/Input/GetInput.h")]
	public class Gyroscope
	{
		private int m_GyroIndex;

		public Vector3 rotationRate => rotationRate_Internal(m_GyroIndex);

		public Vector3 rotationRateUnbiased => rotationRateUnbiased_Internal(m_GyroIndex);

		public Vector3 gravity => gravity_Internal(m_GyroIndex);

		public Vector3 userAcceleration => userAcceleration_Internal(m_GyroIndex);

		public Quaternion attitude => attitude_Internal(m_GyroIndex);

		public bool enabled
		{
			get
			{
				return getEnabled_Internal(m_GyroIndex);
			}
			set
			{
				setEnabled_Internal(m_GyroIndex, value);
			}
		}

		public float updateInterval
		{
			get
			{
				return getUpdateInterval_Internal(m_GyroIndex);
			}
			set
			{
				setUpdateInterval_Internal(m_GyroIndex, value);
			}
		}

		internal Gyroscope(int index)
		{
			m_GyroIndex = index;
		}

		[FreeFunction("GetGyroRotationRate")]
		private static Vector3 rotationRate_Internal(int idx)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			rotationRate_Internal_Injected(idx, out var ret);
			return ret;
		}

		[FreeFunction("GetGyroRotationRateUnbiased")]
		private static Vector3 rotationRateUnbiased_Internal(int idx)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			rotationRateUnbiased_Internal_Injected(idx, out var ret);
			return ret;
		}

		[FreeFunction("GetGravity")]
		private static Vector3 gravity_Internal(int idx)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			gravity_Internal_Injected(idx, out var ret);
			return ret;
		}

		[FreeFunction("GetUserAcceleration")]
		private static Vector3 userAcceleration_Internal(int idx)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			userAcceleration_Internal_Injected(idx, out var ret);
			return ret;
		}

		[FreeFunction("GetAttitude")]
		private static Quaternion attitude_Internal(int idx)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			attitude_Internal_Injected(idx, out var ret);
			return ret;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("IsGyroEnabled")]
		private static extern bool getEnabled_Internal(int idx);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("SetGyroEnabled")]
		private static extern void setEnabled_Internal(int idx, bool enabled);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("GetGyroUpdateInterval")]
		private static extern float getUpdateInterval_Internal(int idx);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("SetGyroUpdateInterval")]
		private static extern void setUpdateInterval_Internal(int idx, float interval);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void rotationRate_Internal_Injected(int idx, out Vector3 ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void rotationRateUnbiased_Internal_Injected(int idx, out Vector3 ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void gravity_Internal_Injected(int idx, out Vector3 ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void userAcceleration_Internal_Injected(int idx, out Vector3 ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void attitude_Internal_Injected(int idx, out Quaternion ret);
	}
	public struct LocationInfo
	{
		internal double m_Timestamp;

		internal float m_Latitude;

		internal float m_Longitude;

		internal float m_Altitude;

		internal float m_HorizontalAccuracy;

		internal float m_VerticalAccuracy;

		public float latitude => m_Latitude;

		public float longitude => m_Longitude;

		public float altitude => m_Altitude;

		public float horizontalAccuracy => m_HorizontalAccuracy;

		public float verticalAccuracy => m_VerticalAccuracy;

		public double timestamp => m_Timestamp;
	}
	public enum LocationServiceStatus
	{
		Stopped,
		Initializing,
		Running,
		Failed
	}
	[NativeHeader("Runtime/Input/LocationService.h")]
	[NativeHeader("Runtime/Input/InputBindings.h")]
	public class LocationService
	{
		internal struct HeadingInfo
		{
			public float magneticHeading;

			public float trueHeading;

			public float headingAccuracy;

			public Vector3 raw;

			public double timestamp;
		}

		public bool isEnabledByUser => IsServiceEnabledByUser();

		public LocationServiceStatus status => GetLocationStatus();

		public LocationInfo lastData
		{
			get
			{
				if (status != LocationServiceStatus.Running)
				{
					Debug.Log((object)"Location service updates are not enabled. Check LocationService.status before querying last location.");
				}
				return GetLastLocation();
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("LocationService::IsServiceEnabledByUser")]
		internal static extern bool IsServiceEnabledByUser();

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("LocationService::GetLocationStatus")]
		internal static extern LocationServiceStatus GetLocationStatus();

		[FreeFunction("LocationService::GetLastLocation")]
		internal static LocationInfo GetLastLocation()
		{
			GetLastLocation_Injected(out var ret);
			return ret;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("LocationService::SetDesiredAccuracy")]
		internal static extern void SetDesiredAccuracy(float value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("LocationService::SetDistanceFilter")]
		internal static extern void SetDistanceFilter(float value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("LocationService::StartUpdatingLocation")]
		internal static extern void StartUpdatingLocation();

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("LocationService::StopUpdatingLocation")]
		internal static extern void StopUpdatingLocation();

		[FreeFunction("LocationService::GetLastHeading")]
		internal static HeadingInfo GetLastHeading()
		{
			GetLastHeading_Injected(out var ret);
			return ret;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("LocationService::IsHeadingUpdatesEnabled")]
		internal static extern bool IsHeadingUpdatesEnabled();

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("LocationService::SetHeadingUpdatesEnabled")]
		internal static extern void SetHeadingUpdatesEnabled(bool value);

		public void Start(float desiredAccuracyInMeters, float updateDistanceInMeters)
		{
			SetDesiredAccuracy(desiredAccuracyInMeters);
			SetDistanceFilter(updateDistanceInMeters);
			StartUpdatingLocation();
		}

		public void Start(float desiredAccuracyInMeters)
		{
			Start(desiredAccuracyInMeters, 10f);
		}

		public void Start()
		{
			Start(10f, 10f);
		}

		public void Stop()
		{
			StopUpdatingLocation();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetLastLocation_Injected(out LocationInfo ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetLastHeading_Injected(out HeadingInfo ret);
	}
	public class Compass
	{
		public float magneticHeading => LocationService.GetLastHeading().magneticHeading;

		public float trueHeading => LocationService.GetLastHeading().trueHeading;

		public float headingAccuracy => LocationService.GetLastHeading().headingAccuracy;

		public Vector3 rawVector => LocationService.GetLastHeading().raw;

		public double timestamp => LocationService.GetLastHeading().timestamp;

		public bool enabled
		{
			get
			{
				return LocationService.IsHeadingUpdatesEnabled();
			}
			set
			{
				LocationService.SetHeadingUpdatesEnabled(value);
			}
		}
	}
	[NativeHeader("Runtime/Camera/Camera.h")]
	internal class CameraRaycastHelper
	{
		[FreeFunction("CameraScripting::RaycastTry")]
		internal static GameObject RaycastTry(Camera cam, Ray ray, float distance, int layerMask)
		{
			return RaycastTry_Injected(cam, ref ray, distance, layerMask);
		}

		[FreeFunction("CameraScripting::RaycastTry2D")]
		internal static GameObject RaycastTry2D(Camera cam, Ray ray, float distance, int layerMask)
		{
			return RaycastTry2D_Injected(cam, ref ray, distance, layerMask);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern GameObject RaycastTry_Injected(Camera cam, ref Ray ray, float distance, int layerMask);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern GameObject RaycastTry2D_Injected(Camera cam, ref Ray ray, float distance, int layerMask);
	}
	[NativeHeader("Runtime/Input/InputBindings.h")]
	public class Input
	{
		private static LocationService locationServiceInstance;

		private static Compass compassInstance;

		private static Gyroscope s_MainGyro;

		public static extern bool simulateMouseWithTouches
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			set;
		}

		[NativeThrows]
		public static extern bool anyKey
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		[NativeThrows]
		public static extern bool anyKeyDown
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		[NativeThrows]
		public static extern string inputString
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		[NativeThrows]
		public static Vector3 mousePosition
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				get_mousePosition_Injected(out var ret);
				return ret;
			}
		}

		[NativeThrows]
		public static Vector2 mouseScrollDelta
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				get_mouseScrollDelta_Injected(out var ret);
				return ret;
			}
		}

		public static extern IMECompositionMode imeCompositionMode
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			set;
		}

		public static extern string compositionString
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		public static extern bool imeIsSelected
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		public static Vector2 compositionCursorPos
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				get_compositionCursorPos_Injected(out var ret);
				return ret;
			}
			set
			{
				set_compositionCursorPos_Injected(ref value);
			}
		}

		[Obsolete("eatKeyPressOnTextFieldFocus property is deprecated, and only provided to support legacy behavior.")]
		public static extern bool eatKeyPressOnTextFieldFocus
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			set;
		}

		public static extern bool mousePresent
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("GetMousePresent")]
			get;
		}

		public static extern int penEventCount
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("GetPenEventCount")]
			get;
		}

		public static extern int touchCount
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("GetTouchCount")]
			get;
		}

		public static extern bool touchPressureSupported
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("IsTouchPressureSupported")]
			get;
		}

		public static extern bool stylusTouchSupported
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("IsStylusTouchSupported")]
			get;
		}

		public static extern bool touchSupported
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("IsTouchSupported")]
			get;
		}

		public static extern bool multiTouchEnabled
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("IsMultiTouchEnabled")]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("SetMultiTouchEnabled")]
			set;
		}

		[Obsolete("isGyroAvailable property is deprecated. Please use SystemInfo.supportsGyroscope instead.")]
		public static extern bool isGyroAvailable
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("IsGyroAvailable")]
			get;
		}

		public static extern DeviceOrientation deviceOrientation
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("GetDeviceOrientation")]
			get;
		}

		public static Vector3 acceleration
		{
			[FreeFunction("GetAcceleration")]
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				get_acceleration_Injected(out var ret);
				return ret;
			}
		}

		public static extern bool compensateSensors
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("IsCompensatingSensors")]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("SetCompensatingSensors")]
			set;
		}

		public static extern int accelerationEventCount
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("GetAccelerationCount")]
			get;
		}

		public static extern bool backButtonLeavesApp
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("GetBackButtonLeavesApp")]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			[FreeFunction("SetBackButtonLeavesApp")]
			set;
		}

		public static LocationService location
		{
			get
			{
				if (locationServiceInstance == null)
				{
					locationServiceInstance = new LocationService();
				}
				return locationServiceInstance;
			}
		}

		public static Compass compass
		{
			get
			{
				if (compassInstance == null)
				{
					compassInstance = new Compass();
				}
				return compassInstance;
			}
		}

		public static Gyroscope gyro
		{
			get
			{
				if (s_MainGyro == null)
				{
					s_MainGyro = new Gyroscope(GetGyroInternal());
				}
				return s_MainGyro;
			}
		}

		public static Touch[] touches
		{
			get
			{
				int num = touchCount;
				Touch[] array = new Touch[num];
				for (int i = 0; i < num; i++)
				{
					array[i] = GetTouch(i);
				}
				return array;
			}
		}

		public static AccelerationEvent[] accelerationEvents
		{
			get
			{
				int num = accelerationEventCount;
				AccelerationEvent[] array = new AccelerationEvent[num];
				for (int i = 0; i < num; i++)
				{
					array[i] = GetAccelerationEvent(i);
				}
				return array;
			}
		}

		public static float GetAxis(string axisName)
		{
			return InputUnsafeUtility.GetAxis(axisName);
		}

		public static float GetAxisRaw(string axisName)
		{
			return InputUnsafeUtility.GetAxisRaw(axisName);
		}

		public static bool GetButton(string buttonName)
		{
			return InputUnsafeUtility.GetButton(buttonName);
		}

		public static bool GetButtonDown(string buttonName)
		{
			return InputUnsafeUtility.GetButtonDown(buttonName);
		}

		public static bool GetButtonUp(string buttonName)
		{
			return InputUnsafeUtility.GetButtonUp(buttonName);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		private static extern bool GetKeyInt(KeyCode key);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		private static extern bool GetKeyUpInt(KeyCode key);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		private static extern bool GetKeyDownInt(KeyCode key);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		public static extern bool GetMouseButton(int button);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		public static extern bool GetMouseButtonDown(int button);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		public static extern bool GetMouseButtonUp(int button);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("ResetInput")]
		public static extern void ResetInputAxes();

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		public static extern string[] GetJoystickNames();

		[NativeThrows]
		public static Touch GetTouch(int index)
		{
			GetTouch_Injected(index, out var ret);
			return ret;
		}

		[NativeThrows]
		public static PenData GetPenEvent(int index)
		{
			GetPenEvent_Injected(index, out var ret);
			return ret;
		}

		[NativeThrows]
		public static PenData GetLastPenContactEvent()
		{
			GetLastPenContactEvent_Injected(out var ret);
			return ret;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		public static extern void ResetPenEvents();

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		public static extern void ClearLastPenContactEvent();

		[NativeThrows]
		public static AccelerationEvent GetAccelerationEvent(int index)
		{
			GetAccelerationEvent_Injected(index, out var ret);
			return ret;
		}

		public static bool GetKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetKeyInt(key);
		}

		public static bool GetKey(string name)
		{
			return InputUnsafeUtility.GetKeyString(name);
		}

		public static bool GetKeyUp(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetKeyUpInt(key);
		}

		public static bool GetKeyUp(string name)
		{
			return InputUnsafeUtility.GetKeyUpString(name);
		}

		public static bool GetKeyDown(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetKeyDownInt(key);
		}

		public static bool GetKeyDown(string name)
		{
			return InputUnsafeUtility.GetKeyDownString(name);
		}

		[Conditional("UNITY_EDITOR")]
		internal static void SimulateTouch(Touch touch)
		{
		}

		[FreeFunction("SimulateTouch")]
		[NativeConditional("UNITY_EDITOR")]
		[Conditional("UNITY_EDITOR")]
		private static void SimulateTouchInternal(Touch touch, long timestamp)
		{
			SimulateTouchInternal_Injected(ref touch, timestamp);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[FreeFunction("GetGyro")]
		private static extern int GetGyroInternal();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool CheckDisabled();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetTouch_Injected(int index, out Touch ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetPenEvent_Injected(int index, out PenData ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetLastPenContactEvent_Injected(out PenData ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetAccelerationEvent_Injected(int index, out AccelerationEvent ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void SimulateTouchInternal_Injected(ref Touch touch, long timestamp);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[SpecialName]
		private static extern void get_mousePosition_Injected(out Vector3 ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[SpecialName]
		private static extern void get_mouseScrollDelta_Injected(out Vector2 ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[SpecialName]
		private static extern void get_compositionCursorPos_Injected(out Vector2 ret);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[SpecialName]
		private static extern void set_compositionCursorPos_Injected(ref Vector2 value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[SpecialName]
		private static extern void get_acceleration_Injected(out Vector3 ret);
	}
	internal class SendMouseEvents
	{
		private struct HitInfo
		{
			public GameObject target;

			public Camera camera;

			public void SendMessage(string name)
			{
				target.SendMessage(name, (object)null, (SendMessageOptions)1);
			}

			public static implicit operator bool(HitInfo exists)
			{
				return (Object)(object)exists.target != (Object)null && (Object)(object)exists.camera != (Object)null;
			}

			public static bool Compare(HitInfo lhs, HitInfo rhs)
			{
				return (Object)(object)lhs.target == (Object)(object)rhs.target && (Object)(object)lhs.camera == (Object)(object)rhs.camera;
			}
		}

		public enum LeftMouseButtonState
		{
			NotPressed,
			Pressed,
			PressedThisFrame
		}

		private const int m_HitIndexGUI = 0;

		private const int m_HitIndexPhysics3D = 1;

		private const int m_HitIndexPhysics2D = 2;

		private static bool s_MouseUsed = false;

		private static readonly HitInfo[] m_LastHit = new HitInfo[3];

		private static readonly HitInfo[] m_MouseDownHit = new HitInfo[3];

		private static readonly HitInfo[] m_CurrentHit = new HitInfo[3];

		private static Camera[] m_Cameras;

		public static Func<KeyValuePair<int, Vector2>> s_GetMouseState;

		private static Vector2 s_MousePosition;

		private static bool s_MouseButtonPressedThisFrame;

		private static bool s_MouseButtonIsPressed;

		private static void UpdateMouse()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (s_GetMouseState != null)
			{
				KeyValuePair<int, Vector2> keyValuePair = s_GetMouseState();
				s_MousePosition = keyValuePair.Value;
				s_MouseButtonPressedThisFrame = keyValuePair.Key == 2;
				s_MouseButtonIsPressed = keyValuePair.Key != 0;
			}
			else if (!Input.CheckDisabled())
			{
				s_MousePosition = Vector2.op_Implicit(Input.mousePosition);
				s_MouseButtonPressedThisFrame = Input.GetMouseButtonDown(0);
				s_MouseButtonIsPressed = Input.GetMouseButton(0);
			}
			else
			{
				s_MousePosition = default(Vector2);
				s_MouseButtonPressedThisFrame = false;
				s_MouseButtonIsPressed = false;
			}
		}

		[RequiredByNativeCode]
		private static void SetMouseMoved()
		{
			s_MouseUsed = true;
		}

		[RequiredByNativeCode]
		private static void DoSendMouseEvents(int skipRTCameras)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: 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_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Invalid comparison between Unknown and I4
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Invalid comparison between Unknown and I4
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Invalid comparison between Unknown and I4
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Invalid comparison between Unknown and I4
			UpdateMouse();
			Vector2 val = s_MousePosition;
			int allCamerasCount = Camera.allCamerasCount;
			if (m_Cameras == null || m_Cameras.Length != allCamerasCount)
			{
				m_Cameras = (Camera[])(object)new Camera[allCamerasCount];
			}
			Camera.GetAllCameras(m_Cameras);
			for (int i = 0; i < m_CurrentHit.Length; i++)
			{
				m_CurrentHit[i] = default(HitInfo);
			}
			if (!s_MouseUsed)
			{
				Camera[] cameras = m_Cameras;
				Vector2 val4 = default(Vector2);
				foreach (Camera val2 in cameras)
				{
					if ((Object)(object)val2 == (Object)null || (skipRTCameras != 0 && (Object)(object)val2.targetTexture != (Object)null))
					{
						continue;
					}
					int targetDisplay = val2.targetDisplay;
					Vector3 val3 = Display.RelativeMouseAt(Vector2.op_Implicit(val));
					if (val3 != Vector3.zero)
					{
						int num = (int)val3.z;
						if (num != targetDisplay)
						{
							continue;
						}
						float num2 = Screen.width;
						float num3 = Screen.height;
						if (targetDisplay > 0 && targetDisplay < Display.displays.Length)
						{
							num2 = Display.displays[targetDisplay].systemWidth;
							num3 = Display.displays[targetDisplay].systemHeight;
						}
						((Vector2)(ref val4))..ctor(val3.x / num2, val3.y / num3);
						if (val4.x < 0f || val4.x > 1f || val4.y < 0f || val4.y > 1f)
						{
							continue;
						}
					}
					else
					{
						val3 = Vector2.op_Implicit(val);
					}
					Rect pixelRect = val2.pixelRect;
					if (((Rect)(ref pixelRect)).Contains(val3) && val2.eventMask != 0)
					{
						Ray ray = val2.ScreenPointToRay(val3);
						float z = ((Ray)(ref ray)).direction.z;
						float distance = (Mathf.Approximately(0f, z) ? float.PositiveInfinity : Mathf.Abs((val2.farClipPlane - val2.nearClipPlane) / z));
						GameObject val5 = CameraRaycastHelper.RaycastTry(val2, ray, distance, val2.cullingMask & val2.eventMask);
						if ((Object)(object)val5 != (Object)null)
						{
							m_CurrentHit[1].target = val5;
							m_CurrentHit[1].camera = val2;
						}
						else if ((int)val2.clearFlags == 1 || (int)val2.clearFlags == 2)
						{
							m_CurrentHit[1].target = null;
							m_CurrentHit[1].camera = null;
						}
						GameObject val6 = CameraRaycastHelper.RaycastTry2D(val2, ray, distance, val2.cullingMask & val2.eventMask);
						if ((Object)(object)val6 != (Object)null)
						{
							m_CurrentHit[2].target = val6;
							m_CurrentHit[2].camera = val2;
						}
						else if ((int)val2.clearFlags == 1 || (int)val2.clearFlags == 2)
						{
							m_CurrentHit[2].target = null;
							m_CurrentHit[2].camera = null;
						}
					}
				}
			}
			for (int k = 0; k < m_CurrentHit.Length; k++)
			{
				SendEvents(k, m_CurrentHit[k]);
			}
			s_MouseUsed = false;
		}

		private static void SendEvents(int i, HitInfo hit)
		{
			bool flag = s_MouseButtonPressedThisFrame;
			bool flag2 = s_MouseButtonIsPressed;
			if (flag)
			{
				if ((bool)hit)
				{
					m_MouseDownHit[i] = hit;
					m_MouseDownHit[i].SendMessage("OnMouseDown");
				}
			}
			else if (!flag2)
			{
				if ((bool)m_MouseDownHit[i])
				{
					if (HitInfo.Compare(hit, m_MouseDownHit[i]))
					{
						m_MouseDownHit[i].SendMessage("OnMouseUpAsButton");
					}
					m_MouseDownHit[i].SendMessage("OnMouseUp");
					m_MouseDownHit[i] = default(HitInfo);
				}
			}
			else if ((bool)m_MouseDownHit[i])
			{
				m_MouseDownHit[i].SendMessage("OnMouseDrag");
			}
			if (HitInfo.Compare(hit, m_LastHit[i]))
			{
				if ((bool)hit)
				{
					hit.SendMessage("OnMouseOver");
				}
			}
			else
			{
				if ((bool)m_LastHit[i])
				{
					m_LastHit[i].SendMessage("OnMouseExit");
				}
				if ((bool)hit)
				{
					hit.SendMessage("OnMouseEnter");
					hit.SendMessage("OnMouseOver");
				}
			}
			m_LastHit[i] = hit;
		}
	}
}
namespace UnityEngine.Internal
{
	[NativeHeader("Runtime/Input/InputBindings.h")]
	internal static class InputUnsafeUtility
	{
		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		internal static extern bool GetKeyString(string name);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		[RequiredMember]
		internal unsafe static extern bool GetKeyString__Unmanaged(byte* name, int nameLen);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		internal static extern bool GetKeyUpString(string name);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		[RequiredMember]
		internal unsafe static extern bool GetKeyUpString__Unmanaged(byte* name, int nameLen);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		internal static extern bool GetKeyDownString(string name);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		[RequiredMember]
		internal unsafe static extern bool GetKeyDownString__Unmanaged(byte* name, int nameLen);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		internal static extern float GetAxis(string axisName);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[RequiredMember]
		[NativeThrows]
		internal unsafe static extern float GetAxis__Unmanaged(byte* axisName, int axisNameLen);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		internal static extern float GetAxisRaw(string axisName);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		[RequiredMember]
		internal unsafe static extern float GetAxisRaw__Unmanaged(byte* axisName, int axisNameLen);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		internal static extern bool GetButton(string buttonName);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		[RequiredMember]
		internal unsafe static extern bool GetButton__Unmanaged(byte* buttonName, int buttonNameLen);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		internal static extern bool GetButtonDown(string buttonName);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		[RequiredMember]
		internal unsafe static extern byte GetButtonDown__Unmanaged(byte* buttonName, int buttonNameLen);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[NativeThrows]
		internal static extern bool GetButtonUp(string buttonName);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[RequiredMember]
		[NativeThrows]
		internal unsafe static extern bool GetButtonUp__Unmanaged(byte* buttonName, int buttonNameLen);
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using tanu.CruiseAssist;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("CruiseAssist")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CruiseAssist")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9cdb5e0f-fb97-46ff-a4fb-a9a400443fd3")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[HarmonyPatch(typeof(PlayerMove_Drift))]
internal class Patch_PlayerMoveDrift
{
	[HarmonyPatch("GameTick")]
	[HarmonyPrefix]
	public static void GameTick_Prefix(PlayerMove_Drift __instance)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Invalid comparison between Unknown and I4
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		if (!CruiseAssistPlugin.Enable || !CruiseAssistPlugin.TargetSelected || (int)((PlayerAction)__instance).controller.movementStateInFrame != 1)
		{
			return;
		}
		if (VFInput._moveForward.pressing || VFInput._pullUp.pressing)
		{
			CruiseAssistPlugin.Interrupt = true;
			CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
			{
				extension.CancelOperate();
			});
		}
		else
		{
			CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
			{
				extension.OperateDrift(__instance);
			});
		}
	}
}
[HarmonyPatch(typeof(PlayerMove_Fly))]
internal class Patch_PlayerMoveFly
{
	[HarmonyPatch("GameTick")]
	[HarmonyPrefix]
	public static void GameTick_Prefix(PlayerMove_Fly __instance)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Invalid comparison between Unknown and I4
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		if (!CruiseAssistPlugin.Enable || !CruiseAssistPlugin.TargetSelected || (int)((PlayerAction)__instance).controller.movementStateInFrame != 2)
		{
			return;
		}
		if (VFInput._moveForward.pressing || VFInput._pullUp.pressing)
		{
			CruiseAssistPlugin.Interrupt = true;
			CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
			{
				extension.CancelOperate();
			});
		}
		else
		{
			CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
			{
				extension.OperateFly(__instance);
			});
		}
	}
}
[HarmonyPatch(typeof(PlayerMove_Walk))]
internal class Patch_PlayerMoveWalk
{
	[HarmonyPatch("GameTick")]
	[HarmonyPrefix]
	public static void GameTick_Prefix(PlayerMove_Walk __instance)
	{
		//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_057b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0585: Unknown result type (might be due to invalid IL or missing references)
		//IL_058a: Unknown result type (might be due to invalid IL or missing references)
		//IL_058f: Unknown result type (might be due to invalid IL or missing references)
		//IL_05cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_05de: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_070d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0713: Invalid comparison between Unknown and I4
		//IL_0621: Unknown result type (might be due to invalid IL or missing references)
		//IL_062b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0630: Unknown result type (might be due to invalid IL or missing references)
		//IL_0635: Unknown result type (might be due to invalid IL or missing references)
		//IL_0716: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0400: Unknown result type (might be due to invalid IL or missing references)
		//IL_0664: Unknown result type (might be due to invalid IL or missing references)
		//IL_066e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0673: Unknown result type (might be due to invalid IL or missing references)
		//IL_0678: Unknown result type (might be due to invalid IL or missing references)
		//IL_0434: Unknown result type (might be due to invalid IL or missing references)
		//IL_043e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0443: Unknown result type (might be due to invalid IL or missing references)
		//IL_0448: Unknown result type (might be due to invalid IL or missing references)
		//IL_06c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_06dd: Unknown result type (might be due to invalid IL or missing references)
		CruiseAssistPlugin.lastState = CruiseAssistPlugin.State;
		if (CruiseAssistPlugin.Interrupt)
		{
			CruiseAssistPlugin.lockOn = false;
			CruiseAssistPlugin.State = CruiseAssistState.INACTIVE;
			CruiseAssistPlugin.SelectTargetPlanet = null;
			CruiseAssistPlugin.SelectTargetStar = null;
			CruiseAssistPlugin.SelectTargetHive = null;
			CruiseAssistPlugin.SelectTargetMsg = null;
			CruiseAssistPlugin.SelectTargetEnemyIdF = 0;
			CruiseAssistPlugin.lastState = CruiseAssistState.INACTIVE;
			CruiseAssistPlugin.AbortPreloadStar();
		}
		CruiseAssistPlugin.State = CruiseAssistState.INACTIVE;
		CruiseAssistPlugin.Interrupt = false;
		CruiseAssistPlugin.TargetStar = null;
		CruiseAssistPlugin.TargetPlanet = null;
		CruiseAssistPlugin.TargetHive = null;
		CruiseAssistPlugin.TargetMsg = null;
		CruiseAssistPlugin.TargetEnemyId = 0;
		CruiseAssistPlugin.TargetRange = 0.0;
		CruiseAssistPlugin.TargetSelected = false;
		if (GameMain.localPlanet != null && (CruiseAssistPlugin.History.Count == 0 || CruiseAssistPlugin.History.Last() != GameMain.localPlanet.id))
		{
			if (CruiseAssistPlugin.History.Count >= 128)
			{
				CruiseAssistPlugin.History.RemoveAt(0);
			}
			CruiseAssistPlugin.History.Add(GameMain.localPlanet.id);
			ConfigManager.CheckConfig(ConfigManager.Step.STATE);
		}
		if (!CruiseAssistPlugin.Enable)
		{
			CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
			{
				extension.SetInactive();
			});
			return;
		}
		int indicatorAstroId = GameMain.mainPlayer.navigation.indicatorAstroId;
		int indicatorEnemyId = GameMain.mainPlayer.navigation.indicatorEnemyId;
		int indicatorMsgId = GameMain.mainPlayer.navigation.indicatorMsgId;
		if ((Object)(object)UIRoot.instance.uiGame.starmap.focusHive != (Object)null)
		{
			return;
		}
		if (CruiseAssistPlugin.SelectTargetAstroId != indicatorAstroId)
		{
			CruiseAssistPlugin.SelectTargetAstroId = indicatorAstroId;
			if (indicatorAstroId == 0)
			{
				CruiseAssistPlugin.SelectTargetPlanet = null;
				CruiseAssistPlugin.SelectTargetStar = null;
			}
			else
			{
				if (indicatorAstroId > 1000000)
				{
					CruiseAssistPlugin.SelectTargetHive = GameMain.spaceSector.dfHivesByAstro[indicatorAstroId - 1000000];
					CruiseAssistPlugin.SelectTargetPlanet = null;
					CruiseAssistPlugin.SelectTargetStar = CruiseAssistPlugin.SelectTargetHive.starData;
				}
				else if (indicatorAstroId % 100 != 0)
				{
					CruiseAssistPlugin.SelectTargetPlanet = GameMain.galaxy.PlanetById(indicatorAstroId);
					CruiseAssistPlugin.SelectTargetStar = CruiseAssistPlugin.SelectTargetPlanet.star;
				}
				else
				{
					CruiseAssistPlugin.SelectTargetPlanet = null;
					CruiseAssistPlugin.SelectTargetStar = GameMain.galaxy.StarById(indicatorAstroId / 100);
				}
				CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
				{
					extension.SetTargetAstroId(indicatorAstroId);
				});
			}
		}
		if (CruiseAssistPlugin.SelectTargetEnemyId != indicatorEnemyId)
		{
			CruiseAssistPlugin.SelectTargetEnemyId = indicatorEnemyId;
			if (indicatorEnemyId != 0)
			{
				CruiseAssistPlugin.SelectTargetEnemyIdF = indicatorEnemyId;
				CruiseAssistPlugin.SelectTargetPlanet = null;
				CruiseAssistPlugin.SelectTargetStar = null;
				CruiseAssistPlugin.SelectTargetHive = null;
				CruiseAssistPlugin.SelectTargetMsg = null;
				CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
				{
					extension.SetTargetAstroId(indicatorAstroId);
				});
			}
			else
			{
				CruiseAssistPlugin.SelectTargetEnemyIdF = 0;
			}
		}
		if (CruiseAssistPlugin.SelectTargetMsgId != indicatorMsgId)
		{
			CruiseAssistPlugin.SelectTargetMsgId = indicatorMsgId;
			if (indicatorMsgId == 0)
			{
				CruiseAssistPlugin.SelectTargetMsg = null;
			}
			else
			{
				CruiseAssistPlugin.SelectTargetMsg = GameMain.gameScenario.cosmicMessageManager.messages[indicatorMsgId];
				CruiseAssistPlugin.SelectTargetStar = CruiseAssistPlugin.SelectTargetMsg.nearStar;
				CruiseAssistPlugin.SelectTargetEnemyIdF = 0;
				CruiseAssistPlugin.SelectTargetPlanet = null;
				CruiseAssistPlugin.SelectTargetHive = null;
				CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
				{
					extension.SetTargetAstroId(indicatorAstroId);
				});
			}
		}
		VectorLF3 val;
		if (CruiseAssistPlugin.SelectTargetStar != null)
		{
			if (GameMain.localStar != null && CruiseAssistPlugin.SelectTargetStar.id == GameMain.localStar.id)
			{
				if (CruiseAssistPlugin.SelectTargetPlanet == null && CruiseAssistPlugin.SelectTargetHive == null && GameMain.localPlanet != null)
				{
					CruiseAssistPlugin.SelectTargetStar = null;
					CruiseAssistPlugin.SelectTargetEnemyId = 0;
					CruiseAssistPlugin.SelectTargetAstroId = 0;
					GameMain.mainPlayer.navigation.indicatorAstroId = 0;
					CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
					{
						extension.SetInactive();
					});
					return;
				}
				if (CruiseAssistPlugin.SelectTargetPlanet != null)
				{
					if (GameMain.localPlanet != null && CruiseAssistPlugin.SelectTargetPlanet.id == GameMain.localPlanet.id)
					{
						CruiseAssistPlugin.Deactivate();
						return;
					}
					CruiseAssistPlugin.TargetPlanet = CruiseAssistPlugin.SelectTargetPlanet;
				}
				else if (CruiseAssistPlugin.SelectTargetHive != null)
				{
					val = GameMain.spaceSector.astros[CruiseAssistPlugin.SelectTargetHive.hiveAstroId - 1000000].uPos - GameMain.mainPlayer.uPosition;
					if (((VectorLF3)(ref val)).magnitude < 30000.0)
					{
						CruiseAssistPlugin.Deactivate();
						return;
					}
					CruiseAssistPlugin.TargetHive = CruiseAssistPlugin.SelectTargetHive;
				}
				else if (CruiseAssistPlugin.SelectTargetMsg != null)
				{
					val = CruiseAssistPlugin.SelectTargetMsg.uPosition - GameMain.mainPlayer.uPosition;
					if (((VectorLF3)(ref val)).magnitude < 2000.0)
					{
						CruiseAssistPlugin.Deactivate();
						return;
					}
					CruiseAssistPlugin.TargetMsg = CruiseAssistPlugin.SelectTargetMsg;
				}
				else if (CruiseAssistPlugin.ReticuleTargetPlanet != null)
				{
					CruiseAssistPlugin.TargetPlanet = CruiseAssistPlugin.ReticuleTargetPlanet;
				}
			}
			else
			{
				CruiseAssistPlugin.TargetStar = CruiseAssistPlugin.SelectTargetStar;
				CruiseAssistPlugin.TargetPlanet = CruiseAssistPlugin.SelectTargetPlanet;
				CruiseAssistPlugin.TargetHive = CruiseAssistPlugin.SelectTargetHive;
			}
		}
		else if (CruiseAssistPlugin.SelectTargetEnemyIdF != 0)
		{
			val = CruiseAssistPlugin.SelectTargetEnemy.pos - GameMain.mainPlayer.uPosition;
			if (((VectorLF3)(ref val)).magnitude < 3000.0)
			{
				CruiseAssistPlugin.Deactivate();
				return;
			}
			CruiseAssistPlugin.TargetEnemyId = CruiseAssistPlugin.SelectTargetEnemyId;
		}
		else if (CruiseAssistPlugin.ReticuleTargetPlanet != null)
		{
			CruiseAssistPlugin.SelectTargetPlanet = CruiseAssistPlugin.ReticuleTargetPlanet;
			CruiseAssistPlugin.SelectTargetStar = CruiseAssistPlugin.SelectTargetPlanet.star;
			CruiseAssistPlugin.TargetPlanet = CruiseAssistPlugin.ReticuleTargetPlanet;
			CruiseAssistPlugin.TargetStar = CruiseAssistPlugin.TargetPlanet.star;
		}
		else if (CruiseAssistPlugin.ReticuleTargetStar != null)
		{
			CruiseAssistPlugin.SelectTargetPlanet = null;
			CruiseAssistPlugin.SelectTargetStar = CruiseAssistPlugin.ReticuleTargetStar;
			CruiseAssistPlugin.TargetPlanet = null;
			CruiseAssistPlugin.TargetStar = CruiseAssistPlugin.ReticuleTargetStar;
		}
		_ = ((PlayerAction)__instance).player;
		if (CruiseAssistPlugin.TargetPlanet != null)
		{
			CruiseAssistPlugin.State = CruiseAssistState.TO_PLANET;
			CruiseAssistPlugin.TargetStar = CruiseAssistPlugin.TargetPlanet.star;
			val = CruiseAssistPlugin.TargetUPos - GameMain.mainPlayer.uPosition;
			CruiseAssistPlugin.TargetRange = ((VectorLF3)(ref val)).magnitude - (double)CruiseAssistPlugin.TargetPlanet.realRadius;
			CruiseAssistPlugin.TargetSelected = true;
		}
		else if (CruiseAssistPlugin.TargetHive != null)
		{
			CruiseAssistPlugin.State = CruiseAssistState.TO_HIVE;
			CruiseAssistPlugin.TargetStar = CruiseAssistPlugin.TargetHive.starData;
			val = CruiseAssistPlugin.TargetUPos - GameMain.mainPlayer.uPosition;
			CruiseAssistPlugin.TargetRange = ((VectorLF3)(ref val)).magnitude - 30000.0;
			CruiseAssistPlugin.TargetSelected = true;
		}
		else if (CruiseAssistPlugin.TargetMsg != null)
		{
			CruiseAssistPlugin.State = CruiseAssistState.TO_MSG;
			CruiseAssistPlugin.TargetStar = CruiseAssistPlugin.TargetMsg.nearStar;
			val = CruiseAssistPlugin.TargetUPos - GameMain.mainPlayer.uPosition;
			CruiseAssistPlugin.TargetRange = ((VectorLF3)(ref val)).magnitude - 2000.0;
			CruiseAssistPlugin.TargetSelected = true;
		}
		else if (CruiseAssistPlugin.TargetEnemyId != 0)
		{
			CruiseAssistPlugin.State = CruiseAssistState.TO_ENEMY;
			val = CruiseAssistPlugin.TargetUPos - GameMain.mainPlayer.uPosition;
			CruiseAssistPlugin.TargetRange = ((VectorLF3)(ref val)).magnitude;
			CruiseAssistPlugin.TargetSelected = true;
		}
		else
		{
			if (CruiseAssistPlugin.TargetStar == null)
			{
				CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
				{
					extension.SetInactive();
				});
				return;
			}
			CruiseAssistPlugin.State = CruiseAssistState.TO_STAR;
			val = CruiseAssistPlugin.TargetStar.uPosition - GameMain.mainPlayer.uPosition;
			CruiseAssistPlugin.TargetRange = ((VectorLF3)(ref val)).magnitude - (double)(CruiseAssistPlugin.TargetStar.viewRadius - 120f);
			CruiseAssistPlugin.TargetSelected = true;
		}
		if ((int)((PlayerAction)__instance).controller.movementStateInFrame > 0)
		{
			return;
		}
		if (VFInput._jump.pressing)
		{
			CruiseAssistPlugin.Interrupt = true;
			CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
			{
				extension.CancelOperate();
			});
		}
		else
		{
			CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
			{
				extension.OperateWalk(__instance);
			});
		}
	}
}
[HarmonyPatch(typeof(PlayerMove_Sail))]
internal class Patch_PlayerMoveSail
{
	[HarmonyPatch("GameTick")]
	[HarmonyPrefix]
	public static void GameTick_Prefix(PlayerMove_Sail __instance)
	{
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_0203: Unknown result type (might be due to invalid IL or missing references)
		//IL_0208: Unknown result type (might be due to invalid IL or missing references)
		//IL_020f: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0224: Unknown result type (might be due to invalid IL or missing references)
		//IL_022b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_0235: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
		//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_01fa: Unknown result type (might be due to invalid IL or missing references)
		if (CruiseAssistPlugin.TargetStar?.id == GameMain.localStar?.id)
		{
			CruiseAssistPlugin.AbortPreloadStar();
		}
		if (!CruiseAssistPlugin.Enable || !CruiseAssistPlugin.TargetSelected)
		{
			return;
		}
		Player player = ((PlayerAction)__instance).player;
		if (!player.sailing)
		{
			return;
		}
		if (GameMain.mainPlayer.controller.input0 != Vector4.zero || (GameMain.mainPlayer.controller.input1 != Vector4.zero && GameMain.mainPlayer.controller.input1.y >= 0f))
		{
			CruiseAssistPlugin.Interrupt = true;
			CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
			{
				extension.CancelOperate();
			});
			return;
		}
		bool operate = false;
		CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
		{
			operate |= extension.OperateSail(__instance);
		});
		if (operate)
		{
			return;
		}
		VectorLF3 val = CruiseAssistPlugin.TargetUPos - player.uPosition;
		float num = Vector3.Angle(VectorLF3.op_Implicit(val), VectorLF3.op_Implicit(player.uVelocity));
		float num2 = 1.6f / Mathf.Max(10f, num);
		_ = ((VectorLF3)(ref player.controller.actionSail.visual_uvel)).magnitude;
		if ((double)num < 0.5)
		{
			CruiseAssistPlugin.lockOn = true;
		}
		if (CruiseAssistPlugin.lockOn)
		{
			if (CruiseAssistPlugin.TargetStar != null)
			{
				CruiseAssistPlugin.TryPreloadStar(CruiseAssistPlugin.TargetStar);
			}
			player.uVelocity = VectorLF3.op_Implicit(Vector3.Slerp(VectorLF3.op_Implicit(player.uVelocity), VectorLF3.op_Implicit(((VectorLF3)(ref val)).normalized * ((VectorLF3)(ref player.uVelocity)).magnitude), 0.75f));
		}
		else
		{
			player.uVelocity = VectorLF3.op_Implicit(Vector3.Slerp(VectorLF3.op_Implicit(player.uVelocity), VectorLF3.op_Implicit(((VectorLF3)(ref val)).normalized * ((VectorLF3)(ref player.uVelocity)).magnitude), num2));
		}
		if (CruiseAssistPlugin.State == CruiseAssistState.TO_ENEMY)
		{
			player.controller.actionSail.warpSpeedControl = 1.0 - Math.Pow(Maths.Clamp01(1.0 - (((VectorLF3)(ref val)).magnitude - 3000.0) / 400000.0), 2.0) * 0.65;
		}
	}
}
namespace tanu.CruiseAssist;

public class ListUtils
{
	public static string ToString(List<int> list)
	{
		if (list == null || list.Count == 0)
		{
			return "";
		}
		return list.Select((int id) => id.ToString()).Aggregate((string a, string b) => a + "," + b);
	}

	public static string ToString(List<string> list)
	{
		if (list == null || list.Count == 0)
		{
			return "";
		}
		return list.Aggregate((string a, string b) => a + "," + b);
	}

	public static List<int> ParseToIntList(string str)
	{
		if (str == null || str.Length == 0)
		{
			return new List<int>();
		}
		int result;
		return (from s in str.Split(new char[1] { ',' })
			where int.TryParse(s, out result)
			select s).Select(int.Parse).ToList();
	}

	public static List<string> ParseToStringList(string str)
	{
		if (str == null || str.Length == 0)
		{
			return new List<string>();
		}
		return str.Split(new char[1] { ',' }).ToList();
	}
}
public class CruiseAssistConfigManager : ConfigManager
{
	public CruiseAssistConfigManager(ConfigFile Config)
		: base(Config)
	{
	}

	protected override void CheckConfigImplements(Step step)
	{
		bool flag = false;
		if (step == Step.AWAKE)
		{
			ConfigManager.Bind("Base", "ModVersion", "1.3.1", "Don't change.").Value = "1.3.1";
			ConfigManager.Migration("State", "MainWindow0Left", 100, "State", "InfoWindowLeft");
			ConfigManager.Migration("State", "MainWindow0Top", 100, "State", "InfoWindowTop");
			ConfigManager.Migration("State", "MainWindow0Left", 100, "State", "MainWindowLeft");
			ConfigManager.Migration("State", "MainWindow0Top", 100, "State", "MainWindowTop");
			ConfigManager.Migration("State", "StarListWindow0Left", 100, "State", "StarListWindowLeft");
			ConfigManager.Migration("State", "StarListWindow0Top", 100, "State", "StarListWindowTop");
			flag = true;
		}
		switch (step)
		{
		case Step.AWAKE:
		case Step.GAME_MAIN_BEGIN:
		{
			CruiseAssistDebugUI.Show = ConfigManager.Bind("Debug", "DebugWindowShow", defaultValue: false).Value;
			CruiseAssistPlugin.Enable = ConfigManager.Bind("Setting", "Enable", defaultValue: true).Value;
			CruiseAssistPlugin.MarkVisitedFlag = ConfigManager.Bind("Setting", "MarkVisited", defaultValue: true).Value;
			CruiseAssistPlugin.SelectFocusFlag = ConfigManager.Bind("Setting", "SelectFocus", defaultValue: true).Value;
			CruiseAssistPlugin.HideDuplicateHistoryFlag = ConfigManager.Bind("Setting", "HideDuplicateHistory", defaultValue: true).Value;
			CruiseAssistPlugin.AutoDisableLockCursorFlag = ConfigManager.Bind("Setting", "AutoDisableLockCursor", defaultValue: false).Value;
			CruiseAssistPlugin.TrackDarkFogSeedsFlag = ConfigManager.Bind("Setting", "TrackDarkFogSeeds", defaultValue: true).Value;
			CruiseAssistPlugin.PreventNonTargetLoadingFlag = ConfigManager.Bind("Setting", "PreventNonTargetLoading", defaultValue: true).Value;
			CruiseAssistPlugin.DisplaySeedETAFlag = ConfigManager.Bind("Setting", "DisplaySeedETA", defaultValue: true).Value;
			CruiseAssistMainUI.Scale = ConfigManager.Bind("Setting", "UIScale", 150).Value;
			EnumUtils.TryParse<CruiseAssistMainUIViewMode>(ConfigManager.Bind("Setting", "MainWindowViewMode", CruiseAssistMainUIViewMode.FULL.ToString()).Value, out CruiseAssistMainUI.ViewMode);
			for (int j = 0; j < 2; j++)
			{
				((Rect)(ref CruiseAssistMainUI.Rect[j])).x = ConfigManager.Bind("State", $"MainWindow{j}Left", 100).Value;
				((Rect)(ref CruiseAssistMainUI.Rect[j])).y = ConfigManager.Bind("State", $"MainWindow{j}Top", 100).Value;
				((Rect)(ref CruiseAssistStarListUI.Rect[j])).x = ConfigManager.Bind("State", $"StarListWindow{j}Left", 100).Value;
				((Rect)(ref CruiseAssistStarListUI.Rect[j])).y = ConfigManager.Bind("State", $"StarListWindow{j}Top", 100).Value;
				((Rect)(ref CruiseAssistConfigUI.Rect[j])).x = ConfigManager.Bind("State", $"ConfigWindow{j}Left", 100).Value;
				((Rect)(ref CruiseAssistConfigUI.Rect[j])).y = ConfigManager.Bind("State", $"ConfigWindow{j}Top", 100).Value;
			}
			CruiseAssistStarListUI.ListSelected = ConfigManager.Bind("State", "StarListWindowListSelected", 0).Value;
			((Rect)(ref CruiseAssistDebugUI.Rect)).x = ConfigManager.Bind("State", "DebugWindowLeft", 100).Value;
			((Rect)(ref CruiseAssistDebugUI.Rect)).y = ConfigManager.Bind("State", "DebugWindowTop", 100).Value;
			if (!DSPGame.IsMenuDemo && GameMain.galaxy != null)
			{
				CruiseAssistPlugin.History = ListUtils.ParseToIntList(ConfigManager.Bind("Save", $"History_{GameMain.galaxy.seed}", "").Value);
				CruiseAssistPlugin.Bookmark = ListUtils.ParseToIntList(ConfigManager.Bind("Save", $"Bookmark_{GameMain.galaxy.seed}", "").Value);
			}
			else
			{
				CruiseAssistPlugin.History = new List<int>();
				CruiseAssistPlugin.Bookmark = new List<int>();
			}
			break;
		}
		case Step.STATE:
		{
			LogManager.LogInfo("check state.");
			flag |= ConfigManager.UpdateEntry("Setting", "Enable", CruiseAssistPlugin.Enable);
			flag |= ConfigManager.UpdateEntry("Setting", "MarkVisited", CruiseAssistPlugin.MarkVisitedFlag);
			flag |= ConfigManager.UpdateEntry("Setting", "SelectFocus", CruiseAssistPlugin.SelectFocusFlag);
			flag |= ConfigManager.UpdateEntry("Setting", "HideDuplicateHistory", CruiseAssistPlugin.HideDuplicateHistoryFlag);
			flag |= ConfigManager.UpdateEntry("Setting", "AutoDisableLockCursor", CruiseAssistPlugin.AutoDisableLockCursorFlag);
			flag |= ConfigManager.UpdateEntry("Setting", "TrackDarkFogSeeds", CruiseAssistPlugin.TrackDarkFogSeedsFlag);
			flag |= ConfigManager.UpdateEntry("Setting", "PreventNonTargetLoading", CruiseAssistPlugin.PreventNonTargetLoadingFlag);
			flag |= ConfigManager.UpdateEntry("Setting", "DisplaySeedETA", CruiseAssistPlugin.DisplaySeedETAFlag);
			flag |= ConfigManager.UpdateEntry("Setting", "UIScale", (int)CruiseAssistMainUI.Scale);
			flag |= ConfigManager.UpdateEntry("Setting", "MainWindowViewMode", CruiseAssistMainUI.ViewMode.ToString());
			for (int i = 0; i < 2; i++)
			{
				flag |= ConfigManager.UpdateEntry("State", $"MainWindow{i}Left", (int)((Rect)(ref CruiseAssistMainUI.Rect[i])).x);
				flag |= ConfigManager.UpdateEntry("State", $"MainWindow{i}Top", (int)((Rect)(ref CruiseAssistMainUI.Rect[i])).y);
				flag |= ConfigManager.UpdateEntry("State", $"StarListWindow{i}Left", (int)((Rect)(ref CruiseAssistStarListUI.Rect[i])).x);
				flag |= ConfigManager.UpdateEntry("State", $"StarListWindow{i}Top", (int)((Rect)(ref CruiseAssistStarListUI.Rect[i])).y);
				flag |= ConfigManager.UpdateEntry("State", $"ConfigWindow{i}Left", (int)((Rect)(ref CruiseAssistConfigUI.Rect[i])).x);
				flag |= ConfigManager.UpdateEntry("State", $"ConfigWindow{i}Top", (int)((Rect)(ref CruiseAssistConfigUI.Rect[i])).y);
			}
			flag |= ConfigManager.UpdateEntry("State", "StarListWindowListSelected", CruiseAssistStarListUI.ListSelected);
			flag |= ConfigManager.UpdateEntry("State", "DebugWindowLeft", (int)((Rect)(ref CruiseAssistDebugUI.Rect)).x);
			flag |= ConfigManager.UpdateEntry("State", "DebugWindowTop", (int)((Rect)(ref CruiseAssistDebugUI.Rect)).y);
			if (!DSPGame.IsMenuDemo && GameMain.galaxy != null)
			{
				if (!ConfigManager.ContainsKey("Save", $"History_{GameMain.galaxy.seed}") || !ConfigManager.ContainsKey("Save", $"Bookmark_{GameMain.galaxy.seed}"))
				{
					ConfigManager.Bind("Save", $"History_{GameMain.galaxy.seed}", "");
					ConfigManager.Bind("Save", $"Bookmark_{GameMain.galaxy.seed}", "");
					flag = true;
				}
				flag |= ConfigManager.UpdateEntry("Save", $"History_{GameMain.galaxy.seed}", ListUtils.ToString(CruiseAssistPlugin.History));
				flag |= ConfigManager.UpdateEntry("Save", $"Bookmark_{GameMain.galaxy.seed}", ListUtils.ToString(CruiseAssistPlugin.Bookmark));
			}
			CruiseAssistMainUI.NextCheckGameTick = long.MaxValue;
			break;
		}
		}
		if (flag)
		{
			ConfigManager.Save();
		}
	}
}
public interface CruiseAssistExtensionAPI
{
	void CheckConfig(string step);

	void SetTargetAstroId(int astroId);

	bool OperateWalk(PlayerMove_Walk __instance);

	bool OperateDrift(PlayerMove_Drift __instance);

	bool OperateFly(PlayerMove_Fly __instance);

	bool OperateSail(PlayerMove_Sail __instance);

	void SetInactive();

	void CancelOperate();

	void OnGUI();

	bool CheckActive();
}
[BepInPlugin("nord.CruiseAssist", "CruiseAssist-N", "1.3.1")]
public class CruiseAssistPlugin : BaseUnityPlugin
{
	public const string ModGuid = "nord.CruiseAssist";

	public const string ModName = "CruiseAssist-N";

	public const string ModVersion = "1.3.1";

	public const double HIVE_IN_RANGE = 30000.0;

	public const double ENEMY_IN_RANGE = 3000.0;

	public const double MSG_IN_RANGE = 2000.0;

	public static bool Enable = true;

	public static bool Interrupt = false;

	public static bool TargetSelected = false;

	public static bool MarkVisitedFlag = true;

	public static bool SelectFocusFlag = false;

	public static bool HideDuplicateHistoryFlag = true;

	public static bool AutoDisableLockCursorFlag = false;

	public static bool TrackDarkFogSeedsFlag = true;

	public static bool PreventNonTargetLoadingFlag = true;

	public static bool DisplaySeedETAFlag = true;

	public static StarData ReticuleTargetStar = null;

	public static PlanetData ReticuleTargetPlanet = null;

	public static StarData SelectTargetStar = null;

	public static PlanetData SelectTargetPlanet = null;

	public static EnemyDFHiveSystem SelectTargetHive = null;

	public static CosmicMessageData SelectTargetMsg = null;

	public static int SelectTargetAstroId = 0;

	public static int SelectTargetEnemyId = 0;

	public static int SelectTargetEnemyIdF = 0;

	public static int SelectTargetMsgId = 0;

	public static StarData TargetStar = null;

	public static PlanetData TargetPlanet = null;

	public static EnemyDFHiveSystem TargetHive = null;

	public static CosmicMessageData TargetMsg = null;

	public static int TargetEnemyId = 0;

	public static bool lockOn = false;

	public static StarData preloadStar = null;

	public static CruiseAssistState State = CruiseAssistState.INACTIVE;

	public static CruiseAssistState lastState = CruiseAssistState.INACTIVE;

	public static List<int> History = new List<int>();

	public static List<int> Bookmark = new List<int>();

	public static Func<StarData, string> GetStarName = (StarData star) => star.displayName;

	public static Func<PlanetData, string> GetPlanetName = (PlanetData planet) => planet.displayName;

	public static Func<EnemyDFHiveSystem, string> GetHiveName = (EnemyDFHiveSystem hive) => hive.displayName;

	public static Func<EnemyData, string> GetEnemyName = (EnemyData enemy) => ((Proto)((ProtoSet<EnemyProto>)(object)LDB.enemies).Select((int)enemy.protoId)).name;

	public static Func<CosmicMessageData, string> GetMsgName = delegate(CosmicMessageData msg)
	{
		int protoId = msg.protoId;
		string text = "";
		text = Localization.Translate("宇宙讯息");
		if (protoId > CosmicMessageProto.maxProtoId)
		{
			text = Localization.Translate("黑雾通讯器");
		}
		return text;
	};

	private Harmony harmony;

	internal static List<CruiseAssistExtensionAPI> extensions = new List<CruiseAssistExtensionAPI>();

	public static double TargetRange = 0.0;

	public static EnemyData SelectTargetEnemy => GameMain.spaceSector.enemyPool[SelectTargetEnemyId];

	public static EnemyData TargetEnemy => GameMain.spaceSector.enemyPool[TargetEnemyId];

	public static VectorLF3 TargetUPos
	{
		get
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (TargetPlanet != null)
			{
				return TargetPlanet.uPosition;
			}
			if (TargetHive != null)
			{
				return GameMain.spaceSector.astros[TargetHive.hiveAstroId - 1000000].uPos;
			}
			if (TargetEnemyId != 0)
			{
				VectorLF3 zero = VectorLF3.zero;
				ref EnemyData reference = ref GameMain.spaceSector.enemyPool[TargetEnemyId];
				GameMain.spaceSector.TransformFromAstro_ref(reference.astroId, ref zero, ref reference.pos);
				return zero;
			}
			if (TargetMsg != null)
			{
				return TargetMsg.uPosition;
			}
			if (TargetStar == null)
			{
				return GameMain.mainPlayer.uPosition;
			}
			return TargetStar.uPosition;
		}
	}

	public static bool CheckActive()
	{
		return State != CruiseAssistState.INACTIVE;
	}

	public void Awake()
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Expected O, but got Unknown
		LogManager.Logger = ((BaseUnityPlugin)this).Logger;
		new CruiseAssistConfigManager(((BaseUnityPlugin)this).Config);
		ConfigManager.CheckConfig(ConfigManager.Step.AWAKE);
		harmony = new Harmony("nord.CruiseAssist.Patch");
		harmony.PatchAll(typeof(Patch_GameMain));
		harmony.PatchAll(typeof(Patch_UISailPanel));
		harmony.PatchAll(typeof(Patch_UIStarmap));
		harmony.PatchAll(typeof(Patch_UITechTree));
		harmony.PatchAll(typeof(Patch_PlayerMoveWalk));
		harmony.PatchAll(typeof(Patch_PlayerMoveDrift));
		harmony.PatchAll(typeof(Patch_PlayerMoveFly));
		harmony.PatchAll(typeof(Patch_PlayerMoveSail));
		harmony.PatchAll(typeof(Patch_DeterminLocalPlanet));
	}

	public void OnDestroy()
	{
		harmony.UnpatchSelf();
	}

	public void OnGUI()
	{
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		if (DSPGame.IsMenuDemo || GameMain.mainPlayer == null)
		{
			return;
		}
		UIGame uiGame = UIRoot.instance.uiGame;
		if (!uiGame.guideComplete || ((ManualBehaviour)uiGame.techTree).active || ((ManualBehaviour)uiGame.escMenu).active || ((ManualBehaviour)uiGame.dysonEditor).active || uiGame.hideAllUI0 || uiGame.hideAllUI1 || ((Object)(object)UIMilkyWayLoadingSplash.instance != (Object)null && ((ManualBehaviour)UIMilkyWayLoadingSplash.instance).active) || ((Object)(object)UIRoot.instance.uiMilkyWay != (Object)null && ((ManualBehaviour)UIRoot.instance.uiMilkyWay).active) || VFInput.inCombatScreenGUI || ((ManualBehaviour)uiGame.controlPanelWindow).active || ((ManualBehaviour)uiGame.dashboard).active || ((ManualBehaviour)uiGame.statWindow).active || ((ManualBehaviour)uiGame.blueprintBrowser).active)
		{
			return;
		}
		bool extensionActive = false;
		extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
		{
			extensionActive |= extension.CheckActive();
		});
		if (GameMain.mainPlayer.sailing || ((ManualBehaviour)uiGame.starmap).active || extensionActive)
		{
			CruiseAssistMainUI.wIdx = (((ManualBehaviour)uiGame.starmap).active ? 1 : 0);
			float num = CruiseAssistMainUI.Scale / 100f;
			GUIUtility.ScaleAroundPivot(new Vector2(num, num), Vector2.zero);
			CruiseAssistMainUI.OnGUI();
			if (CruiseAssistStarListUI.Show[CruiseAssistMainUI.wIdx])
			{
				CruiseAssistStarListUI.OnGUI();
			}
			if (CruiseAssistConfigUI.Show[CruiseAssistMainUI.wIdx])
			{
				CruiseAssistConfigUI.OnGUI();
			}
			if (CruiseAssistDebugUI.Show)
			{
				CruiseAssistDebugUI.OnGUI();
			}
			bool flag = false;
			flag = ResetInput(CruiseAssistMainUI.Rect[CruiseAssistMainUI.wIdx], num);
			if (!flag && CruiseAssistStarListUI.Show[CruiseAssistMainUI.wIdx])
			{
				flag = ResetInput(CruiseAssistStarListUI.Rect[CruiseAssistMainUI.wIdx], num);
			}
			if (!flag && CruiseAssistConfigUI.Show[CruiseAssistMainUI.wIdx])
			{
				flag = ResetInput(CruiseAssistConfigUI.Rect[CruiseAssistMainUI.wIdx], num);
			}
			if (!flag && CruiseAssistDebugUI.Show)
			{
				flag = ResetInput(CruiseAssistDebugUI.Rect, num);
			}
			extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
			{
				extension.OnGUI();
			});
		}
	}

	private bool ResetInput(Rect rect, float scale)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		float num = ((Rect)(ref rect)).xMin * scale;
		float num2 = ((Rect)(ref rect)).xMax * scale;
		float num3 = ((Rect)(ref rect)).yMin * scale;
		float num4 = ((Rect)(ref rect)).yMax * scale;
		float x = Input.mousePosition.x;
		float num5 = (float)Screen.height - Input.mousePosition.y;
		if (num <= x && x <= num2 && num3 <= num5 && num5 <= num4 && (((IEnumerable<int>)new int[3] { 0, 1, 2 }).Any((Func<int, bool>)Input.GetMouseButton) || Input.mouseScrollDelta.y != 0f))
		{
			Input.ResetInputAxes();
			return true;
		}
		return false;
	}

	public static void RegistExtension(CruiseAssistExtensionAPI extension)
	{
		extensions.Add(extension);
	}

	public static void UnregistExtension(Type type)
	{
		extensions.RemoveAll((CruiseAssistExtensionAPI extension) => extension.GetType().FullName == type.FullName);
	}

	public static void Deactivate()
	{
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		SelectTargetStar = null;
		SelectTargetHive = null;
		SelectTargetPlanet = null;
		SelectTargetMsg = null;
		SelectTargetAstroId = 0;
		SelectTargetEnemyId = 0;
		SelectTargetMsgId = 0;
		GameMain.mainPlayer.navigation.indicatorAstroId = 0;
		GameMain.mainPlayer.navigation.indicatorEnemyId = 0;
		GameMain.mainPlayer.navigation.indicatorMsgId = 0;
		lockOn = false;
		AbortPreloadStar();
		extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
		{
			extension.SetInactive();
		});
		Player mainPlayer = GameMain.mainPlayer;
		if (lastState != CruiseAssistState.INACTIVE && State == CruiseAssistState.INACTIVE && mainPlayer.warping && mainPlayer.warpCommand)
		{
			mainPlayer.warpCommand = false;
			VFAudio.Create("warp-end", mainPlayer.transform, Vector3.zero, true, 0, -1, -1L);
		}
	}

	public static EnemyDFHiveSystem GetSeedsTargetHive(EnemyData seed)
	{
		//IL_0000: 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_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		if (seed.dfTinderId <= 0)
		{
			return null;
		}
		EnemyDFHiveSystem hiveByAstroId = GameMain.spaceSector.GetHiveByAstroId(seed.astroId);
		if (hiveByAstroId == null)
		{
			return null;
		}
		ref DFTinderComponent reference = ref hiveByAstroId.tinders.buffer[seed.dfTinderId];
		if (reference.id == seed.dfTinderId && reference.direction > 0 && reference.stage >= -1)
		{
			return GameMain.spaceSector.GetHiveByAstroId(reference.targetHiveAstroId);
		}
		return null;
	}

	public static void TryPreloadStar(StarData star)
	{
		if (GameMain.localStar == null && star?.id != preloadStar?.id && !star.loaded && GameMain.isRunning)
		{
			if (preloadStar != null)
			{
				AbortPreloadStar();
			}
			preloadStar = star;
			LogManager.LogInfo("Try to preload the star.");
		}
	}

	public static void AbortPreloadStar()
	{
		if (preloadStar != null)
		{
			if (GameMain.localStar?.id != preloadStar.id && preloadStar.loaded)
			{
				LogManager.LogInfo("Abort star's preloading.");
			}
			preloadStar = null;
		}
	}
}
public abstract class ConfigManager
{
	public enum Step
	{
		AWAKE,
		GAME_MAIN_BEGIN,
		UNIVERSE_GEN_CREATE_GALAXY,
		STATE
	}

	private static ConfigManager instance;

	private static Dictionary<ConfigDefinition, string> orphanedEntries;

	public static ConfigFile Config { get; private set; }

	protected ConfigManager(ConfigFile config)
	{
		instance = this;
		Config = config;
		Config.SaveOnConfigSet = false;
	}

	public static void CheckConfig(Step step)
	{
		instance.CheckConfigImplements(step);
	}

	protected abstract void CheckConfigImplements(Step step);

	public static ConfigEntry<T> Bind<T>(ConfigDefinition configDefinition, T defaultValue, ConfigDescription configDescription = null)
	{
		return Config.Bind<T>(configDefinition, defaultValue, configDescription);
	}

	public static ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, ConfigDescription configDescription = null)
	{
		return Config.Bind<T>(section, key, defaultValue, configDescription);
	}

	public static ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, string description)
	{
		return Config.Bind<T>(section, key, defaultValue, description);
	}

	public static ConfigEntry<T> GetEntry<T>(ConfigDefinition configDefinition)
	{
		try
		{
			return (ConfigEntry<T>)(object)Config[configDefinition];
		}
		catch (KeyNotFoundException ex)
		{
			LogManager.LogError($"{ex.GetType()}: configDefinition={configDefinition}");
			throw;
		}
	}

	public static ConfigEntry<T> GetEntry<T>(string section, string key)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		return GetEntry<T>(new ConfigDefinition(section, key));
	}

	public static T GetValue<T>(ConfigDefinition configDefinition)
	{
		return GetEntry<T>(configDefinition).Value;
	}

	public static T GetValue<T>(string section, string key)
	{
		return GetEntry<T>(section, key).Value;
	}

	public static bool ContainsKey(ConfigDefinition configDefinition)
	{
		return Config.ContainsKey(configDefinition);
	}

	public static bool ContainsKey(string section, string key)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		return Config.ContainsKey(new ConfigDefinition(section, key));
	}

	public static bool UpdateEntry<T>(string section, string key, T value) where T : IComparable
	{
		ConfigEntry<T> entry = GetEntry<T>(section, key);
		if (entry.Value.CompareTo(value) == 0)
		{
			return false;
		}
		entry.Value = value;
		return true;
	}

	public static bool RemoveEntry(ConfigDefinition key)
	{
		return Config.Remove(key);
	}

	public static Dictionary<ConfigDefinition, string> GetOrphanedEntries()
	{
		if (orphanedEntries == null)
		{
			orphanedEntries = Traverse.Create((object)Config).Property<Dictionary<ConfigDefinition, string>>("OrphanedEntries", (object[])null).Value;
		}
		return orphanedEntries;
	}

	public static void Migration<T>(string newSection, string newKey, T defaultValue, string oldSection, string oldKey)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Expected O, but got Unknown
		GetOrphanedEntries();
		ConfigDefinition key = new ConfigDefinition(oldSection, oldKey);
		if (orphanedEntries.TryGetValue(key, out var value))
		{
			((ConfigEntryBase)Bind(newSection, newKey, defaultValue)).SetSerializedValue(value);
			orphanedEntries.Remove(key);
			LogManager.LogInfo("migration " + oldSection + "." + oldKey + "(" + value + ") => " + newSection + "." + newKey);
		}
	}

	public static void Save(bool clearOrphanedEntries = false)
	{
		if (clearOrphanedEntries)
		{
			GetOrphanedEntries().Clear();
		}
		Config.Save();
		LogManager.LogInfo("save config.");
	}
}
[HarmonyPatch(typeof(GameData), "ArriveStar")]
public class Patch_ArriveStar
{
	[HarmonyPrefix]
	public static bool ArriveStar_Prefix(StarData star)
	{
		if (CruiseAssistPlugin.preloadStar != null && CruiseAssistPlugin.preloadStar.id != star?.id)
		{
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(GameData), "DetermineLocalPlanet")]
public class Patch_DeterminLocalPlanet
{
	[HarmonyPrefix]
	public static bool DetermineLocalPlanet_Prefix(ref bool __result)
	{
		if (!CruiseAssistPlugin.PreventNonTargetLoadingFlag)
		{
			return true;
		}
		StarData val = null;
		PlanetData val2 = null;
		GameMain.data.GetNearestStarPlanet(ref val, ref val2);
		if (CruiseAssistPlugin.preloadStar != null && val?.id != CruiseAssistPlugin.preloadStar.id)
		{
			__result = false;
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(UIStarmap))]
public class Patch_UIStarmap
{
	[HarmonyPatch("_OnClose")]
	[HarmonyPrefix]
	public static void OnClose_Prefix()
	{
		ConfigManager.CheckConfig(ConfigManager.Step.STATE);
		CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
		{
			extension.CheckConfig(ConfigManager.Step.STATE.ToString());
		});
	}
}
[HarmonyPatch(typeof(UITechTree))]
public class Patch_UITechTree
{
	[HarmonyPatch("_OnOpen")]
	[HarmonyPrefix]
	public static void OnOpen_Prefix()
	{
		ConfigManager.CheckConfig(ConfigManager.Step.STATE);
		CruiseAssistPlugin.extensions.ForEach(delegate(CruiseAssistExtensionAPI extension)
		{
			extension.CheckConfig(ConfigManager.Step.STATE.ToString());
		});
	}
}
public class CruiseAssistConfigUI
{
	private static int wIdx = 0;

	public const float WindowWidth = 400f;

	public const float WindowHeight = 400f;

	public static bool[] Show = new bool[2];

	public static Rect[] Rect = (Rect[])(object)new Rect[2]
	{
		new Rect(0f, 0f, 400f, 400f),
		new Rect(0f, 0f, 400f, 400f)
	};

	private static float lastCheckWindowLeft = float.MinValue;

	private static float lastCheckWindowTop = float.MinValue;

	public static float TempScale = 150f;

	private static GUIStyle windowStyle;

	private static GUIStyle mainWindowStyleLabelStyle;

	private static GUIStyle mainWindowStyleButtonStyle;

	private static GUIStyle uiScaleTitleLabelStyle;

	private static GUIStyle scaleSliderStyle;

	private static GUIStyle scaleSliderThumbStyle;

	private static GUIStyle uiScaleValueLabelStyle;

	private static GUIStyle scaleSetButtonStyle;

	private static GUIStyle toggleStyle;

	private static GUIStyle closeButtonStyle;

	public static void OnGUI()
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Expected O, but got Unknown
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		CruiseAssistMainUI.StyleStuff();
		wIdx = CruiseAssistMainUI.wIdx;
		windowStyle = (GUIStyle)(((object)windowStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.WindowStyle)
		{
			fontSize = 11
		}));
		Rect[wIdx] = GUILayout.Window(99030293, Rect[wIdx], new WindowFunction(WindowFunction), "CruiseAssist - Config", windowStyle, Array.Empty<GUILayoutOption>());
		float num = CruiseAssistMainUI.Scale / 100f;
		if ((float)Screen.width / num < ((Rect)(ref Rect[wIdx])).xMax)
		{
			((Rect)(ref Rect[wIdx])).x = (float)Screen.width / num - ((Rect)(ref Rect[wIdx])).width;
		}
		if (((Rect)(ref Rect[wIdx])).x < 0f)
		{
			((Rect)(ref Rect[wIdx])).x = 0f;
		}
		if ((float)Screen.height / num < ((Rect)(ref Rect[wIdx])).yMax)
		{
			((Rect)(ref Rect[wIdx])).y = (float)Screen.height / num - ((Rect)(ref Rect[wIdx])).height;
		}
		if (((Rect)(ref Rect[wIdx])).y < 0f)
		{
			((Rect)(ref Rect[wIdx])).y = 0f;
		}
		if (lastCheckWindowLeft != float.MinValue && (((Rect)(ref Rect[wIdx])).x != lastCheckWindowLeft || ((Rect)(ref Rect[wIdx])).y != lastCheckWindowTop))
		{
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		lastCheckWindowLeft = ((Rect)(ref Rect[wIdx])).x;
		lastCheckWindowTop = ((Rect)(ref Rect[wIdx])).y;
	}

	public static void WindowFunction(int windowId)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: 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_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0220: Unknown result type (might be due to invalid IL or missing references)
		//IL_0225: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_023b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0285: Unknown result type (might be due to invalid IL or missing references)
		//IL_028a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0313: Unknown result type (might be due to invalid IL or missing references)
		//IL_0318: Unknown result type (might be due to invalid IL or missing references)
		//IL_0323: Unknown result type (might be due to invalid IL or missing references)
		//IL_032b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0368: 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_040c: Unknown result type (might be due to invalid IL or missing references)
		//IL_045e: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0502: Unknown result type (might be due to invalid IL or missing references)
		//IL_0554: Unknown result type (might be due to invalid IL or missing references)
		//IL_0597: Unknown result type (might be due to invalid IL or missing references)
		//IL_059c: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_05db: Unknown result type (might be due to invalid IL or missing references)
		GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		mainWindowStyleLabelStyle = (GUIStyle)(((object)mainWindowStyleLabelStyle) ?? ((object)new GUIStyle(GUI.skin.label)
		{
			fixedWidth = 120f,
			fixedHeight = 20f,
			fontSize = 12,
			alignment = (TextAnchor)3
		}));
		GUILayout.Label("Main Window Style :", mainWindowStyleLabelStyle, Array.Empty<GUILayoutOption>());
		mainWindowStyleButtonStyle = (GUIStyle)(((object)mainWindowStyleButtonStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.BaseToolbarButtonStyle)
		{
			fixedWidth = 80f,
			fixedHeight = 20f,
			fontSize = 12
		}));
		string[] array = new string[2] { "FULL", "MINI" };
		int num = ((CruiseAssistMainUI.ViewMode != CruiseAssistMainUIViewMode.FULL) ? 1 : 0);
		GUI.changed = false;
		int num2 = GUILayout.Toolbar(num, array, mainWindowStyleButtonStyle, Array.Empty<GUILayoutOption>());
		if (GUI.changed)
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
		}
		if (num2 != num)
		{
			switch (num2)
			{
			case 0:
				CruiseAssistMainUI.ViewMode = CruiseAssistMainUIViewMode.FULL;
				break;
			case 1:
				CruiseAssistMainUI.ViewMode = CruiseAssistMainUIViewMode.MINI;
				break;
			}
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUILayout.EndHorizontal();
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		uiScaleTitleLabelStyle = (GUIStyle)(((object)uiScaleTitleLabelStyle) ?? ((object)new GUIStyle(GUI.skin.label)
		{
			fixedWidth = 60f,
			fixedHeight = 20f,
			fontSize = 12,
			alignment = (TextAnchor)3
		}));
		GUILayout.Label("UI Scale :", uiScaleTitleLabelStyle, Array.Empty<GUILayoutOption>());
		object obj = scaleSliderStyle;
		if (obj == null)
		{
			GUIStyle val = new GUIStyle(CruiseAssistMainUI.BaseHorizontalSliderStyle)
			{
				fixedWidth = 180f
			};
			val.margin.top = 10;
			val.alignment = (TextAnchor)3;
			obj = (object)val;
		}
		scaleSliderStyle = (GUIStyle)obj;
		scaleSliderThumbStyle = (GUIStyle)(((object)scaleSliderThumbStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.BaseHorizontalSliderThumbStyle)));
		TempScale = GUILayout.HorizontalSlider(TempScale, 80f, 240f, scaleSliderStyle, scaleSliderThumbStyle, Array.Empty<GUILayoutOption>());
		TempScale = (int)TempScale / 5 * 5;
		uiScaleValueLabelStyle = (GUIStyle)(((object)uiScaleValueLabelStyle) ?? ((object)new GUIStyle(GUI.skin.label)
		{
			fixedWidth = 40f,
			fixedHeight = 20f,
			fontSize = 12,
			alignment = (TextAnchor)3
		}));
		GUILayout.Label(TempScale.ToString("0") + "%", uiScaleValueLabelStyle, Array.Empty<GUILayoutOption>());
		object obj2 = scaleSetButtonStyle;
		if (obj2 == null)
		{
			GUIStyle val2 = new GUIStyle(CruiseAssistMainUI.BaseButtonStyle)
			{
				fixedWidth = 60f,
				fixedHeight = 18f
			};
			val2.margin.top = 6;
			val2.fontSize = 12;
			obj2 = (object)val2;
		}
		scaleSetButtonStyle = (GUIStyle)obj2;
		if (GUILayout.Button("SET", scaleSetButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			CruiseAssistMainUI.Scale = TempScale;
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUILayout.EndHorizontal();
		toggleStyle = (GUIStyle)(((object)toggleStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.BaseToggleStyle)
		{
			fixedHeight = 20f,
			fontSize = 12,
			alignment = (TextAnchor)3
		}));
		GUI.changed = false;
		CruiseAssistPlugin.MarkVisitedFlag = GUILayout.Toggle(CruiseAssistPlugin.MarkVisitedFlag, "Mark the visited system and planet.", toggleStyle, Array.Empty<GUILayoutOption>());
		if (GUI.changed)
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUI.changed = false;
		CruiseAssistPlugin.SelectFocusFlag = GUILayout.Toggle(CruiseAssistPlugin.SelectFocusFlag, "Focus when target selected.", toggleStyle, Array.Empty<GUILayoutOption>());
		if (GUI.changed)
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUI.changed = false;
		CruiseAssistPlugin.HideDuplicateHistoryFlag = GUILayout.Toggle(CruiseAssistPlugin.HideDuplicateHistoryFlag, "Hide duplicate history.", toggleStyle, Array.Empty<GUILayoutOption>());
		if (GUI.changed)
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUI.changed = false;
		CruiseAssistPlugin.AutoDisableLockCursorFlag = GUILayout.Toggle(CruiseAssistPlugin.AutoDisableLockCursorFlag, "Disable lock cursor when starting sail mode.", toggleStyle, Array.Empty<GUILayoutOption>());
		if (GUI.changed)
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUI.changed = false;
		CruiseAssistPlugin.TrackDarkFogSeedsFlag = GUILayout.Toggle(CruiseAssistPlugin.TrackDarkFogSeedsFlag, "Display all active Dark Fog seeds in starlist.", toggleStyle, Array.Empty<GUILayoutOption>());
		if (GUI.changed)
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUI.changed = false;
		CruiseAssistPlugin.PreventNonTargetLoadingFlag = GUILayout.Toggle(CruiseAssistPlugin.PreventNonTargetLoadingFlag, "Prevent loading of non-target stars when CruiseAssist is active.", toggleStyle, Array.Empty<GUILayoutOption>());
		if (GUI.changed)
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUI.changed = false;
		CruiseAssistPlugin.DisplaySeedETAFlag = GUILayout.Toggle(CruiseAssistPlugin.DisplaySeedETAFlag, "Display ETA for Dark Fog seeds.", toggleStyle, Array.Empty<GUILayoutOption>());
		if (GUI.changed)
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUILayout.FlexibleSpace();
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.FlexibleSpace();
		closeButtonStyle = (GUIStyle)(((object)closeButtonStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.BaseButtonStyle)
		{
			fixedWidth = 80f,
			fixedHeight = 20f,
			fontSize = 12
		}));
		if (GUILayout.Button("Close", closeButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			Show[wIdx] = false;
		}
		GUILayout.EndHorizontal();
		GUILayout.EndVertical();
		GUI.DragWindow();
	}
}
public class CruiseAssistDebugUI
{
	public static bool Show = false;

	public static Rect Rect = new Rect(0f, 0f, 400f, 400f);

	private static float lastCheckWindowLeft = float.MinValue;

	private static float lastCheckWindowTop = float.MinValue;

	private static long nextCheckGameTick = long.MaxValue;

	private static Vector2 scrollPos = Vector2.zero;

	public static int trackedTinders = 0;

	public static void OnGUI()
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		//IL_001d: 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_003e: Expected O, but got Unknown
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		GUIStyle val = new GUIStyle(GUI.skin.window);
		val.fontSize = 11;
		Rect = GUILayout.Window(99030294, Rect, new WindowFunction(WindowFunction), "CruiseAssist - Debug", val, Array.Empty<GUILayoutOption>());
		_ = CruiseAssistMainUI.Scale / 100f;
		if ((float)Screen.width < ((Rect)(ref Rect)).xMax)
		{
			((Rect)(ref Rect)).x = (float)Screen.width - ((Rect)(ref Rect)).width;
		}
		if (((Rect)(ref Rect)).x < 0f)
		{
			((Rect)(ref Rect)).x = 0f;
		}
		if ((float)Screen.height < ((Rect)(ref Rect)).yMax)
		{
			((Rect)(ref Rect)).y = (float)Screen.height - ((Rect)(ref Rect)).height;
		}
		if (((Rect)(ref Rect)).y < 0f)
		{
			((Rect)(ref Rect)).y = 0f;
		}
		if (lastCheckWindowLeft != float.MinValue && (((Rect)(ref Rect)).x != lastCheckWindowLeft || ((Rect)(ref Rect)).y != lastCheckWindowTop))
		{
			nextCheckGameTick = GameMain.gameTick + 300;
		}
		lastCheckWindowLeft = ((Rect)(ref Rect)).x;
		lastCheckWindowTop = ((Rect)(ref Rect)).y;
		if (nextCheckGameTick <= GameMain.gameTick)
		{
			ConfigManager.CheckConfig(ConfigManager.Step.STATE);
			nextCheckGameTick = long.MaxValue;
		}
	}

	public static void WindowFunction(int windowId)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Expected O, but got Unknown
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0271: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
		GUIStyle val = new GUIStyle(GUI.skin.label);
		val.fontSize = 12;
		scrollPos = GUILayout.BeginScrollView(scrollPos, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"trackedTinders={trackedTinders}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.lockOn={CruiseAssistPlugin.lockOn}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.preloadStar={CruiseAssistPlugin.preloadStar?.id}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.localStar={GameMain.localStar?.id}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.localPlanet={GameMain.localPlanet?.id}", val, Array.Empty<GUILayoutOption>());
		StarData preloadStar = CruiseAssistPlugin.preloadStar;
		GUILayout.Label($"CruiseAssist.preloadStar.loaded={((preloadStar != null) ? new bool?(preloadStar.loaded) : null)}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.ReticuleTargetStar.id={CruiseAssistPlugin.ReticuleTargetStar?.id}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.ReticuleTargetPlanet.id={CruiseAssistPlugin.ReticuleTargetPlanet?.id}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.SelectTargetStar.id={CruiseAssistPlugin.SelectTargetStar?.id}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.SelectTargetPlanet.id={CruiseAssistPlugin.SelectTargetPlanet?.id}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.SelectTargetMsg.protoId={CruiseAssistPlugin.SelectTargetMsg?.protoId}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.TargetUPos={CruiseAssistPlugin.TargetUPos}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.uPosition={GameMain.mainPlayer.uPosition}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.navigation.indicatorAstroId={GameMain.mainPlayer.navigation.indicatorAstroId}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.navigation.indicatorEnemyId={GameMain.mainPlayer.navigation.indicatorEnemyId}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.navigation.indicatorMsgId={GameMain.mainPlayer.navigation.indicatorMsgId}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.controller.input0.w={GameMain.mainPlayer.controller.input0.w}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.controller.input0.x={GameMain.mainPlayer.controller.input0.x}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.controller.input0.y={GameMain.mainPlayer.controller.input0.y}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.controller.input0.z={GameMain.mainPlayer.controller.input0.z}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.controller.input1.w={GameMain.mainPlayer.controller.input1.w}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.controller.input1.x={GameMain.mainPlayer.controller.input1.x}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.controller.input1.y={GameMain.mainPlayer.controller.input1.y}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GameMain.mainPlayer.controller.input1.z={GameMain.mainPlayer.controller.input1.z}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"VFInput._sailSpeedUp={VFInput._sailSpeedUp}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.Enable={CruiseAssistPlugin.Enable}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"CruiseAssist.History={CruiseAssistPlugin.History.Count()}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label("CruiseAssist.History=" + ListUtils.ToString(CruiseAssistPlugin.History), val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GUI.skin.window.margin.top={GUI.skin.window.margin.top}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GUI.skin.window.border.top={GUI.skin.window.border.top}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GUI.skin.window.padding.top={GUI.skin.window.padding.top}", val, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"GUI.skin.window.overflow.top={GUI.skin.window.overflow.top}", val, Array.Empty<GUILayoutOption>());
		GUILayout.EndScrollView();
		GUILayout.EndVertical();
		GUI.DragWindow();
	}
}
public enum CruiseAssistMainUIViewMode
{
	FULL,
	MINI
}
public class CruiseAssistStarListUI
{
	private static int wIdx = 0;

	public const float WindowWidth = 440f;

	public const float WindowHeight = 480f;

	public static bool[] Show = new bool[2];

	public static Rect[] Rect = (Rect[])(object)new Rect[2]
	{
		new Rect(0f, 0f, 440f, 480f),
		new Rect(0f, 0f, 440f, 480f)
	};

	public static int ListSelected = 0;

	public static int[] actionSelected = new int[3];

	private static float lastCheckWindowLeft = float.MinValue;

	private static float lastCheckWindowTop = float.MinValue;

	private static readonly Vector2[] scrollPos = (Vector2[])(object)new Vector2[3]
	{
		Vector2.zero,
		Vector2.zero,
		Vector2.zero
	};

	private const string VisitedMark = "● ";

	private const string NonVisitMark = "";

	public static GUIStyle windowStyle = null;

	public static GUIStyle mainWindowStyleButtonStyle = null;

	public static GUIStyle nameLabelStyle = null;

	public static GUIStyle nRangeLabelStyle = null;

	public static GUIStyle hRangeLabelStyle = null;

	public static GUIStyle nActionButtonStyle = null;

	public static GUIStyle hActionButtonStyle = null;

	public static GUIStyle nSortButtonStyle = null;

	public static GUIStyle hSortButtonStyle = null;

	public static GUIStyle nViewButtonStyle = null;

	public static GUIStyle hViewButtonStyle = null;

	public static GUIStyle buttonStyle = null;

	public static GUIContent cheapText = null;

	public static string[][] listButtonModeName = new string[3][]
	{
		new string[2] { "Target", "Bookmark" },
		new string[3] { "Target", "Bookmark", "Delete" },
		new string[3] { "Target", "Sort", "Delete" }
	};

	private static bool CanDisplayViewButton => ((ManualBehaviour)UIRoot.instance.uiGame.starmap).active;

	public static GUIContent GetCheapGUIContent(string text)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		cheapText = (GUIContent)(((object)cheapText) ?? ((object)new GUIContent()));
		cheapText.text = text;
		return cheapText;
	}

	public static bool IsStarVisited(StarData star)
	{
		if (star != null)
		{
			return star.planets.Where((PlanetData p) => p.factory != null).Count() > 0;
		}
		return false;
	}

	public static void OnGUI()
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		wIdx = CruiseAssistMainUI.wIdx;
		windowStyle = (GUIStyle)(((object)windowStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.WindowStyle)));
		windowStyle.fontSize = 11;
		Rect[wIdx] = GUILayout.Window(99030292, Rect[wIdx], new WindowFunction(WindowFunction), "CruiseAssist - StarList", windowStyle, Array.Empty<GUILayoutOption>());
		float num = CruiseAssistMainUI.Scale / 100f;
		if ((float)Screen.width / num < ((Rect)(ref Rect[wIdx])).xMax)
		{
			((Rect)(ref Rect[wIdx])).x = (float)Screen.width / num - ((Rect)(ref Rect[wIdx])).width;
		}
		if (((Rect)(ref Rect[wIdx])).x < 0f)
		{
			((Rect)(ref Rect[wIdx])).x = 0f;
		}
		if ((float)Screen.height / num < ((Rect)(ref Rect[wIdx])).yMax)
		{
			((Rect)(ref Rect[wIdx])).y = (float)Screen.height / num - ((Rect)(ref Rect[wIdx])).height;
		}
		if (((Rect)(ref Rect[wIdx])).y < 0f)
		{
			((Rect)(ref Rect[wIdx])).y = 0f;
		}
		if (lastCheckWindowLeft != float.MinValue && (((Rect)(ref Rect[wIdx])).x != lastCheckWindowLeft || ((Rect)(ref Rect[wIdx])).y != lastCheckWindowTop))
		{
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		lastCheckWindowLeft = ((Rect)(ref Rect[wIdx])).x;
		lastCheckWindowTop = ((Rect)(ref Rect[wIdx])).y;
	}

	public static void WindowFunction(int windowId)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_022b: 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_02a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0321: Unknown result type (might be due to invalid IL or missing references)
		//IL_0547: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_060e: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_040b: Unknown result type (might be due to invalid IL or missing references)
		GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		mainWindowStyleButtonStyle = (GUIStyle)(((object)mainWindowStyleButtonStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.BaseButtonStyle)));
		mainWindowStyleButtonStyle.fixedWidth = 80f;
		mainWindowStyleButtonStyle.fixedHeight = 20f;
		mainWindowStyleButtonStyle.fontSize = 12;
		string[] array = new string[3] { "Normal", "History", "Bookmark" };
		GUI.changed = false;
		int num = GUILayout.Toolbar(ListSelected, array, mainWindowStyleButtonStyle, Array.Empty<GUILayoutOption>());
		if (GUI.changed)
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
		}
		if (num != ListSelected)
		{
			ListSelected = num;
			CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
		}
		GUILayout.EndHorizontal();
		scrollPos[ListSelected] = GUILayout.BeginScrollView(scrollPos[ListSelected], GUIStyle.none, CruiseAssistMainUI.BaseVerticalScrollBarStyle, Array.Empty<GUILayoutOption>());
		nameLabelStyle = (GUIStyle)(((object)nameLabelStyle) ?? ((object)new GUIStyle(GUI.skin.label)));
		nameLabelStyle.fixedWidth = 240f;
		nameLabelStyle.stretchHeight = true;
		nameLabelStyle.fontSize = 14;
		nameLabelStyle.alignment = (TextAnchor)3;
		nRangeLabelStyle = (GUIStyle)(((object)nRangeLabelStyle) ?? ((object)new GUIStyle(GUI.skin.label)));
		nRangeLabelStyle.fixedWidth = 60f;
		nRangeLabelStyle.fixedHeight = 20f;
		nRangeLabelStyle.fontSize = 14;
		nRangeLabelStyle.alignment = (TextAnchor)5;
		hRangeLabelStyle = (GUIStyle)(((object)hRangeLabelStyle) ?? ((object)new GUIStyle(nRangeLabelStyle)));
		hRangeLabelStyle.fixedHeight = 40f;
		nActionButtonStyle = (GUIStyle)(((object)nActionButtonStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.BaseButtonStyle)));
		nActionButtonStyle.fixedWidth = 40f;
		nActionButtonStyle.fixedHeight = 18f;
		nActionButtonStyle.margin.top = 6;
		nActionButtonStyle.fontSize = 12;
		hActionButtonStyle = (GUIStyle)(((object)hActionButtonStyle) ?? ((object)new GUIStyle(nActionButtonStyle)));
		hActionButtonStyle.margin.top = 16;
		nSortButtonStyle = (GUIStyle)(((object)nSortButtonStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.BaseButtonStyle)));
		nSortButtonStyle.fixedWidth = 20f;
		nSortButtonStyle.fixedHeight = 18f;
		nSortButtonStyle.margin.top = 6;
		nSortButtonStyle.fontSize = 12;
		hSortButtonStyle = (GUIStyle)(((object)hSortButtonStyle) ?? ((object)new GUIStyle(nSortButtonStyle)));
		hSortButtonStyle.margin.top = 16;
		nViewButtonStyle = (GUIStyle)(((object)nViewButtonStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.BaseButtonStyle)));
		nViewButtonStyle.fixedWidth = 20f;
		nViewButtonStyle.fixedHeight = 18f;
		nViewButtonStyle.margin.top = 6;
		nViewButtonStyle.fontSize = 12;
		hViewButtonStyle = (GUIStyle)(((object)hViewButtonStyle) ?? ((object)new GUIStyle(nViewButtonStyle)));
		hViewButtonStyle.margin.top = 16;
		_ = UIRoot.instance.uiGame;
		if (ListSelected == 0)
		{
			List<DFTinderComponent> activeTinders = null;
			CruiseAssistDebugUI.trackedTinders = 0;
			if (CruiseAssistPlugin.TrackDarkFogSeedsFlag)
			{
				activeTinders = new List<DFTinderComponent>();
				EnemyDFHiveSystem[] dfHivesByAstro = GameMain.spaceSector.dfHivesByAstro;
				foreach (EnemyDFHiveSystem val in dfHivesByAstro)
				{
					if (val == null || val.tinderCount == 0)
					{
						continue;
					}
					CruiseAssistDebugUI.trackedTinders += val.tinders.cursor;
					for (int j = 1; j < val.tinders.cursor; j++)
					{
						if (((DFTinderComponent)(ref val.tinders.buffer[j])).ID > 0)
						{
							DFTinderComponent val2 = val.tinders.buffer[j];
							if (val2.stage >= -1 && val2.direction > 0)
							{
								activeTinders.Add(val2);
							}
						}
					}
				}
			}
			CollectionExtensions.Do<Tuple<StarData, double>>((IEnumerable<Tuple<StarData, double>>)(from tuple in GameMain.galaxy.stars.Select(delegate(StarData star)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0016: Unknown result type (might be due to invalid IL or missing references)
					VectorLF3 val9 = star.uPosition - GameMain.mainPlayer.uPosition;
					return new Tuple<StarData, double>(star, ((VectorLF3)(ref val9)).magnitude);
				})
				orderby tuple.v2
				select tuple), (Action<Tuple<StarData, double>>)delegate(Tuple<StarData, double> tuple)
			{
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_074c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0760: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: 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_0792: Unknown result type (might be due to invalid IL or missing references)
				//IL_07a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_06db: Unknown result type (might be due to invalid IL or missing references)
				//IL_06e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0207: Unknown result type (might be due to invalid IL or missing references)
				//IL_025e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0218: Unknown result type (might be due to invalid IL or missing references)
				//IL_0230: Unknown result type (might be due to invalid IL or missing references)
				//IL_0244: Unknown result type (might be due to invalid IL or missing references)
				//IL_08a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0912: Unknown result type (might be due to invalid IL or missing references)
				//IL_0348: Unknown result type (might be due to invalid IL or missing references)
				//IL_0365: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
				StarData star3 = tuple.v1;
				double range = tuple.v2;
				string starName = CruiseAssistPlugin.GetStarName(star3);
				bool flag3 = false;
				List<Tuple<EnemyData, double>> list = new List<Tuple<EnemyData, double>>();
				VectorLF3 val6;
				if (activeTinders != null)
				{
					foreach (DFTinderComponent item in activeTinders)
					{
						EnemyDFHiveSystem hiveByAstroId = GameMain.spaceSector.GetHiveByAstroId(item.targetHiveAstroId);
						if (hiveByAstroId != null && hiveByAstroId.starData.id == star3.id)
						{
							EnemyData val5 = GameMain.spaceSector.enemyPool[item.enemyId];
							val6 = val5.pos - GameMain.mainPlayer.uPosition;
							double magnitude2 = ((VectorLF3)(ref val6)).magnitude;
							list.Add(new Tuple<EnemyData, double>(val5, magnitude2));
						}
					}
					list.Sort((Tuple<EnemyData, double> tuple1, Tuple<EnemyData, double> tuple2) => tuple1.v2.CompareTo(tuple2.v2));
					foreach (Tuple<EnemyData, double> item2 in list)
					{
						GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
						EnemyData v = item2.v1;
						val6 = v.pos - star3.uPosition;
						double magnitude3 = ((VectorLF3)(ref val6)).magnitude;
						float magnitude4 = ((Vector3)(ref v.vel)).magnitude;
						string text3;
						if (magnitude4 <= 0f)
						{
							text3 = "∞";
						}
						else
						{
							double num5 = magnitude3 / (double)magnitude4;
							int num6 = (int)(num5 / 3600.0);
							int num7 = (int)(num5 % 3600.0 / 60.0);
							int num8 = (int)(num5 % 60.0);
							text3 = $"{num6}:{num7:D2}:{num8:D2}";
						}
						double v2 = item2.v2;
						nameLabelStyle.normal.textColor = Color.red;
						nRangeLabelStyle.normal.textColor = Color.red;
						if (CruiseAssistPlugin.TargetEnemyId != 0 && v.id == CruiseAssistPlugin.TargetEnemyId)
						{
							nameLabelStyle.normal.textColor = CruiseAssistMainUI.enemyTextColor;
							nRangeLabelStyle.normal.textColor = CruiseAssistMainUI.enemyTextColor;
						}
						string text4 = starName + " ← " + CruiseAssistPlugin.GetEnemyName(v);
						if (CruiseAssistPlugin.MarkVisitedFlag)
						{
							text4 = (IsStarVisited(star3) ? "● " : "") + text4;
						}
						if (CruiseAssistPlugin.DisplaySeedETAFlag)
						{
							text4 = text4 + " (" + text3 + ")";
						}
						GUILayout.Label(text4, nameLabelStyle, Array.Empty<GUILayoutOption>());
						float num9 = nameLabelStyle.CalcHeight(GetCheapGUIContent(text4), nameLabelStyle.fixedWidth);
						GUILayout.FlexibleSpace();
						GUILayout.Label(CruiseAssistMainUI.RangeToString(v2), (num9 < 30f) ? nRangeLabelStyle : hRangeLabelStyle, Array.Empty<GUILayoutOption>());
						if (GUILayout.Button((actionSelected[ListSelected] == 0) ? "SET" : "-", (num9 < 30f) ? nActionButtonStyle : hActionButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
							if (actionSelected[ListSelected] == 0)
							{
								SelectEnemy(v.id);
							}
						}
						if (CanDisplayViewButton && actionSelected[ListSelected] == 0 && GUILayout.Button("-", (num9 < 30f) ? nSortButtonStyle : hSortButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
						}
						GUILayout.EndHorizontal();
					}
				}
				UIStarmap starmap = UIRoot.instance.uiGame.starmap;
				if (GameMain.localStar != null && star3.id == GameMain.localStar.id)
				{
					flag3 = true;
				}
				else if ((star3.id == CruiseAssistPlugin.SelectTargetStar?.id || star3.id == starmap.focusStar?.star.id || star3.id == starmap.focusPlanet?.planet.star.id || star3.id == starmap.focusHive?.hive.starData.id || star3.id == starmap.viewStar?.id || star3.id == starmap.viewPlanet?.star.id || star3.id == starmap.viewHive?.starData.id) && GameMain.history.universeObserveLevel >= ((range >= 14400000.0) ? 4 : 3))
				{
					flag3 = true;
				}
				if (flag3)
				{
					CollectionExtensions.Do<Tuple<EnemyDFHiveSystem, double>>((IEnumerable<Tuple<EnemyDFHiveSystem, double>>)(from tuple2 in GameMain.spaceSector.dfHivesByAstro.Where((EnemyDFHiveSystem hive) => hive != null && hive.starData.id == star3.id && hive.hasAnyStructureOrUnit).Select(delegate(EnemyDFHiveSystem hive)
						{
							//IL_001c: Unknown result type (might be due to invalid IL or missing references)
							//IL_0026: Unknown result type (might be due to invalid IL or missing references)
							//IL_002b: Unknown result type (might be due to invalid IL or missing references)
							//IL_0030: Unknown result type (might be due to invalid IL or missing references)
							VectorLF3 val8 = GameMain.spaceSector.astros[hive.hiveAstroId - 1000000].uPos - GameMain.mainPlayer.uPosition;
							return new Tuple<EnemyDFHiveSystem, double>(hive, ((VectorLF3)(ref val8)).magnitude);
						})
						orderby tuple2.v2
						select tuple2), (Action<Tuple<EnemyDFHiveSystem, double>>)delegate(Tuple<EnemyDFHiveSystem, double> tuple2)
					{
						//IL_0023: Unknown result type (might be due to invalid IL or missing references)
						//IL_0037: Unknown result type (might be due to invalid IL or missing references)
						//IL_0064: Unknown result type (might be due to invalid IL or missing references)
						//IL_0078: Unknown result type (might be due to invalid IL or missing references)
						//IL_0130: Unknown result type (might be due to invalid IL or missing references)
						//IL_0199: Unknown result type (might be due to invalid IL or missing references)
						GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
						EnemyDFHiveSystem v5 = tuple2.v1;
						double v6 = tuple2.v2;
						nameLabelStyle.normal.textColor = Color.white;
						nRangeLabelStyle.normal.textColor = Color.white;
						if (CruiseAssistPlugin.SelectTargetHive != null && v5.hiveAstroId == CruiseAssistPlugin.SelectTargetHive.hiveAstroId)
						{
							nameLabelStyle.normal.textColor = CruiseAssistMainUI.hiveTextColor;
							nRangeLabelStyle.normal.textColor = CruiseAssistMainUI.hiveTextColor;
						}
						string text8 = starName + " - " + CruiseAssistPlugin.GetHiveName(v5);
						GUILayout.Label(text8, nameLabelStyle, Array.Empty<GUILayoutOption>());
						float num12 = nameLabelStyle.CalcHeight(GetCheapGUIContent(text8), nameLabelStyle.fixedWidth);
						GUILayout.FlexibleSpace();
						GUILayout.Label(CruiseAssistMainUI.RangeToString(v6), (num12 < 30f) ? nRangeLabelStyle : hRangeLabelStyle, Array.Empty<GUILayoutOption>());
						if (GUILayout.Button((actionSelected[ListSelected] == 0) ? "SET" : "-", (num12 < 30f) ? nActionButtonStyle : hActionButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
							if (actionSelected[ListSelected] == 0)
							{
								SelectHive(star3, v5);
							}
						}
						if (CanDisplayViewButton && actionSelected[ListSelected] == 0 && GUILayout.Button("V", (num12 < 30f) ? nViewButtonStyle : hViewButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
							if (actionSelected[ListSelected] == 0)
							{
								SelectHive(star3, v5, set: false);
							}
						}
						GUILayout.EndHorizontal();
					});
					IEnumerable<Tuple<PlanetData, double>> enumerable4 = star3.planets.Select(delegate(PlanetData planet)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						//IL_000c: Unknown result type (might be due to invalid IL or missing references)
						//IL_0011: Unknown result type (might be due to invalid IL or missing references)
						//IL_0016: Unknown result type (might be due to invalid IL or missing references)
						VectorLF3 val7 = planet.uPosition - GameMain.mainPlayer.uPosition;
						return new Tuple<PlanetData, double>(planet, ((VectorLF3)(ref val7)).magnitude);
					});
					val6 = star3.uPosition - GameMain.mainPlayer.uPosition;
					CollectionExtensions.Do<Tuple<PlanetData, double>>((IEnumerable<Tuple<PlanetData, double>>)(from tuple2 in CollectionExtensions.AddItem<Tuple<PlanetData, double>>(enumerable4, new Tuple<PlanetData, double>(null, ((VectorLF3)(ref val6)).magnitude))
						orderby tuple2.v2
						select tuple2), (Action<Tuple<PlanetData, double>>)delegate(Tuple<PlanetData, double> tuple2)
					{
						//IL_0024: Unknown result type (might be due to invalid IL or missing references)
						//IL_0038: Unknown result type (might be due to invalid IL or missing references)
						//IL_0140: Unknown result type (might be due to invalid IL or missing references)
						//IL_0154: Unknown result type (might be due to invalid IL or missing references)
						//IL_0077: Unknown result type (might be due to invalid IL or missing references)
						//IL_008b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0265: Unknown result type (might be due to invalid IL or missing references)
						//IL_032a: Unknown result type (might be due to invalid IL or missing references)
						GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
						PlanetData v3 = tuple2.v1;
						double v4 = tuple2.v2;
						nameLabelStyle.normal.textColor = Color.white;
						nRangeLabelStyle.normal.textColor = Color.white;
						float num11;
						if (v3 == null)
						{
							if (CruiseAssistPlugin.SelectTargetPlanet == null && CruiseAssistPlugin.SelectTargetStar != null && star3.id == CruiseAssistPlugin.SelectTargetStar.id)
							{
								nameLabelStyle.normal.textColor = Color.cyan;
								nRangeLabelStyle.normal.textColor = Color.cyan;
							}
							string text6 = starName;
							if (CruiseAssistPlugin.MarkVisitedFlag)
							{
								text6 = ((star3.planets.Where((PlanetData p) => p.factory != null).Count() > 0) ? "● " : "") + text6;
							}
							GUILayout.Label(text6, nameLabelStyle, Array.Empty<GUILayoutOption>());
							num11 = nameLabelStyle.CalcHeight(GetCheapGUIContent(text6), nameLabelStyle.fixedWidth);
						}
						else
						{
							if (CruiseAssistPlugin.SelectTargetPlanet != null && v3.id == CruiseAssistPlugin.SelectTargetPlanet.id)
							{
								nameLabelStyle.normal.textColor = Color.cyan;
								nRangeLabelStyle.normal.textColor = Color.cyan;
							}
							string text7 = starName + " - " + CruiseAssistPlugin.GetPlanetName(v3);
							if (CruiseAssistPlugin.MarkVisitedFlag)
							{
								text7 = ((v3.factory != null) ? "● " : "") + text7;
							}
							GUILayout.Label(text7, nameLabelStyle, Array.Empty<GUILayoutOption>());
							num11 = nameLabelStyle.CalcHeight(GetCheapGUIContent(text7), nameLabelStyle.fixedWidth);
						}
						GUILayout.FlexibleSpace();
						GUILayout.Label(CruiseAssistMainUI.RangeToString((v3 == null) ? range : v4), (num11 < 30f) ? nRangeLabelStyle : hRangeLabelStyle, Array.Empty<GUILayoutOption>());
						if (GUILayout.Button((actionSelected[ListSelected] == 0) ? "SET" : ((v3 == null) ? "-" : (CruiseAssistPlugin.Bookmark.Contains(v3.id) ? "DEL" : "ADD")), (num11 < 30f) ? nActionButtonStyle : hActionButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
							if (actionSelected[ListSelected] == 0)
							{
								SelectStar(star3, v3);
							}
							else if (v3 != null)
							{
								if (CruiseAssistPlugin.Bookmark.Contains(v3.id))
								{
									CruiseAssistPlugin.Bookmark.Remove(v3.id);
								}
								else if (CruiseAssistPlugin.Bookmark.Count <= 128)
								{
									CruiseAssistPlugin.Bookmark.Add(v3.id);
									CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
								}
							}
						}
						if (CanDisplayViewButton && actionSelected[ListSelected] == 0 && GUILayout.Button("V", (num11 < 30f) ? nViewButtonStyle : hViewButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
							if (actionSelected[ListSelected] == 0)
							{
								SelectStar(star3, v3, set: false);
							}
						}
						GUILayout.EndHorizontal();
					});
				}
				else
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					nameLabelStyle.normal.textColor = Color.white;
					nRangeLabelStyle.normal.textColor = Color.white;
					if (CruiseAssistPlugin.SelectTargetStar != null && star3.id == CruiseAssistPlugin.SelectTargetStar.id)
					{
						nameLabelStyle.normal.textColor = Color.cyan;
						nRangeLabelStyle.normal.textColor = Color.cyan;
					}
					string text5 = starName;
					if (CruiseAssistPlugin.MarkVisitedFlag)
					{
						text5 = ((star3.planets.Where((PlanetData p) => p.factory != null).Count() > 0) ? "● " : "") + text5;
					}
					GUILayout.Label(text5, nameLabelStyle, Array.Empty<GUILayoutOption>());
					float num10 = nameLabelStyle.CalcHeight(GetCheapGUIContent(text5), nameLabelStyle.fixedWidth);
					GUILayout.FlexibleSpace();
					GUILayout.Label(CruiseAssistMainUI.RangeToString(range), (num10 < 30f) ? nRangeLabelStyle : hRangeLabelStyle, Array.Empty<GUILayoutOption>());
					if (GUILayout.Button((actionSelected[ListSelected] == 0) ? "SET" : "-", (num10 < 30f) ? nActionButtonStyle : hActionButtonStyle, Array.Empty<GUILayoutOption>()))
					{
						VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
						if (actionSelected[ListSelected] == 0)
						{
							SelectStar(star3, null);
						}
					}
					if (CanDisplayViewButton && actionSelected[ListSelected] == 0 && GUILayout.Button("V", (num10 < 30f) ? nViewButtonStyle : hViewButtonStyle, Array.Empty<GUILayoutOption>()))
					{
						VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
						if (actionSelected[ListSelected] == 0)
						{
							SelectStar(star3, null, set: false);
						}
					}
					GUILayout.EndHorizontal();
				}
			});
		}
		else if (ListSelected == 1 || ListSelected == 2)
		{
			bool highlighted = false;
			IEnumerable<int> enumerable2;
			if (ListSelected != 1)
			{
				IEnumerable<int> enumerable = CruiseAssistPlugin.Bookmark.ToList();
				enumerable2 = enumerable;
			}
			else
			{
				enumerable2 = Enumerable.Reverse(CruiseAssistPlugin.History);
			}
			IEnumerable<int> enumerable3 = enumerable2;
			if (ListSelected == 1 && actionSelected[ListSelected] != 2 && CruiseAssistPlugin.HideDuplicateHistoryFlag)
			{
				enumerable3 = enumerable3.Distinct();
			}
			int listIndex = -1;
			CollectionExtensions.Do<int>(enumerable3, (Action<int>)delegate(int id)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				//IL_0449: Unknown result type (might be due to invalid IL or missing references)
				//IL_0246: Unknown result type (might be due to invalid IL or missing references)
				int num2 = listIndex + 1;
				listIndex = num2;
				PlanetData val3 = GameMain.galaxy.PlanetById(id);
				if (val3 != null)
				{
					StarData star2 = val3.star;
					string text = CruiseAssistPlugin.GetStarName(star2);
					VectorLF3 val4 = val3.uPosition - GameMain.mainPlayer.uPosition;
					double magnitude = ((VectorLF3)(ref val4)).magnitude;
					nameLabelStyle.normal.textColor = Color.white;
					nRangeLabelStyle.normal.textColor = Color.white;
					if (!highlighted && CruiseAssistPlugin.SelectTargetPlanet != null && val3.id == CruiseAssistPlugin.SelectTargetPlanet.id)
					{
						nameLabelStyle.normal.textColor = Color.cyan;
						nRangeLabelStyle.normal.textColor = Color.cyan;
						highlighted = true;
					}
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					string text2 = text + " - " + CruiseAssistPlugin.GetPlanetName(val3);
					if (CruiseAssistPlugin.MarkVisitedFlag)
					{
						text2 = ((val3.factory != null) ? "● " : "") + text2;
					}
					GUILayout.Label(text2, nameLabelStyle, Array.Empty<GUILayoutOption>());
					float num3 = nameLabelStyle.CalcHeight(GetCheapGUIContent(text2), nameLabelStyle.fixedWidth);
					GUILayout.FlexibleSpace();
					GUILayout.Label(CruiseAssistMainUI.RangeToString(magnitude), (num3 < 30f) ? nRangeLabelStyle : hRangeLabelStyle, Array.Empty<GUILayoutOption>());
					if (ListSelected == 2 && actionSelected[ListSelected] == 1)
					{
						int num4 = CruiseAssistPlugin.Bookmark.IndexOf(id);
						bool flag = num4 == 0;
						bool flag2 = num4 == CruiseAssistPlugin.Bookmark.Count - 1;
						if (GUILayout.Button(flag2 ? "-" : "↓", (num3 < 30f) ? nSortButtonStyle : hSortButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
							if (!flag2)
							{
								CruiseAssistPlugin.Bookmark.RemoveAt(num4);
								CruiseAssistPlugin.Bookmark.Insert(num4 + 1, id);
							}
						}
						if (GUILayout.Button(flag ? "-" : "↑", (num3 < 30f) ? nSortButtonStyle : hSortButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
							if (!flag)
							{
								CruiseAssistPlugin.Bookmark.RemoveAt(num4);
								CruiseAssistPlugin.Bookmark.Insert(num4 - 1, id);
							}
						}
					}
					else
					{
						if (GUILayout.Button((actionSelected[ListSelected] == 0) ? "SET" : ((actionSelected[ListSelected] != 2) ? (CruiseAssistPlugin.Bookmark.Contains(id) ? "DEL" : "ADD") : ((ListSelected == 1 && listIndex == 0) ? "-" : "DEL")), (num3 < 30f) ? nActionButtonStyle : hActionButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
							if (actionSelected[ListSelected] == 0)
							{
								SelectStar(star2, val3);
							}
							else if (actionSelected[ListSelected] == 1)
							{
								if (ListSelected == 1)
								{
									if (CruiseAssistPlugin.Bookmark.Contains(id))
									{
										CruiseAssistPlugin.Bookmark.Remove(id);
									}
									else if (CruiseAssistPlugin.Bookmark.Count <= 128)
									{
										CruiseAssistPlugin.Bookmark.Add(id);
										CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
									}
								}
							}
							else if (actionSelected[ListSelected] == 2)
							{
								if (ListSelected == 1)
								{
									if (listIndex != 0)
									{
										CruiseAssistPlugin.History.RemoveAt(CruiseAssistPlugin.History.Count - 1 - listIndex);
										CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
									}
								}
								else if (ListSelected == 2)
								{
									CruiseAssistPlugin.Bookmark.Remove(val3.id);
									CruiseAssistMainUI.NextCheckGameTick = GameMain.gameTick + 300;
								}
							}
						}
						if (CanDisplayViewButton && actionSelected[ListSelected] == 0 && GUILayout.Button("V", (num3 < 30f) ? nViewButtonStyle : hViewButtonStyle, Array.Empty<GUILayoutOption>()))
						{
							VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
							if (actionSelected[ListSelected] == 0)
							{
								SelectStar(star2, val3, set: false);
							}
						}
					}
					GUILayout.EndHorizontal();
				}
			});
		}
		GUILayout.EndScrollView();
		GUILayout.FlexibleSpace();
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		buttonStyle = (GUIStyle)(((object)buttonStyle) ?? ((object)new GUIStyle(CruiseAssistMainUI.BaseButtonStyle)));
		buttonStyle.fixedWidth = 80f;
		buttonStyle.fixedHeight = 20f;
		buttonStyle.fontSize = 12;
		if (GUILayout.Button(listButtonModeName[ListSelected][actionSelected[ListSelected]], buttonStyle, Array.Empty<GUILayoutOption>()))
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			actionSelected[ListSelected]++;
			actionSelected[ListSelected] %= listButtonModeName[ListSelected].Length;
		}
		GUILayout.FlexibleSpace();
		if (GUILayout.Button("Close", buttonStyle, Array.Empty<GUILayoutOption>()))
		{
			VFAudio.Create("ui-click-0", (Transform)null, Vector3.zero, true, 0, -1, -1L);
			Show[wIdx] = false;
		}
		GUILayout.EndHorizontal();
		GUILayout.EndVertical();
		GUI.DragWindow();
	}

	public static void SelectStar(StarData star, PlanetData planet, bool set = true)
	{
		UIGame uiGame = UIRoot.instance.uiGame;
		if (CruiseAssistPlugin.SelectFocusFlag && ((ManualBehaviour)uiGame.starmap).active)
		{
			if (star != null)
			{
				UIStarmapStar val = uiGame.starmap.starUIs.Where((UIStarmapStar s) => s.star.id == star.id).FirstOrDefault();
				if ((Object)(object)val != (Object)null)
				{
					UIStarmap_OnStarClick(uiGame.starmap, val);
					uiGame.starmap.OnCursorFunction2Click(0);
				}
			}
			if (planet != null)
			{
				UIStarmapPlanet val2 = uiGame.starmap.planetUIs.Where((UIStarmapPlanet p) => p.planet.id == planet.id).FirstOrDefault();
				if ((Object)(object)val2 != (Object)null)
				{
					UIStarmap_OnPlanetClick(uiGame.starmap, val2);
					uiGame.starmap.OnCursorFunction2Click(0);
				}
			}
		}
		if (set)
		{
			if (planet != null)
			{
				GameMain.mainPlayer.navigation.indicatorAstroId = planet.id;
			}
			else if (star != null)
			{
				GameMain.mainPlayer.navi