using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CG;
using CG.Objects;
using CG.Ship.Modules;
using Gameplay.Utilities;
using HarmonyLib;
using MavsLibCore;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Mav's Work")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyDescription("Make the gravity scoop, space worthy.")]
[assembly: AssemblyFileVersion("0.0.5.0")]
[assembly: AssemblyInformationalVersion("0.0.5+9a291d1228113adca1476a07141f1741227c36f6")]
[assembly: AssemblyProduct("Void Crew - Better Scoop")]
[assembly: AssemblyTitle("Better Scoop")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Maverik/VoidCrewMods/tree/main/BetterScoop")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.5.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace BetterScoop
{
	[BepInPlugin("Maverik-BetterScoop", "Better Scoop", "0.0.5")]
	[DisallowMultipleComponent]
	internal sealed class BetterScoop : MavsBepInExPlugin<BetterScoop, PluginConfiguration>
	{
		private static readonly Type _carryableAttractorType = typeof(CarryableAttractor);

		private static readonly FieldInfo _coneAngle = AccessTools.Field(_carryableAttractorType, "_coneAngle");

		private static readonly FieldInfo _pullVelocity = AccessTools.Field(_carryableAttractorType, "_pullVelocity");

		private static readonly FieldInfo _catchRadius = AccessTools.Field(_carryableAttractorType, "_catchRadius");

		private static readonly FieldInfo _inheritVelocityValue = AccessTools.Field(_carryableAttractorType, "_inheritVelocityValue");

		private static readonly HashSet<GUIDUnion> _assetGuidBlacklist = new HashSet<GUIDUnion>
		{
			new GUIDUnion("ec0fc0790a706ef4facab39da5d9de04"),
			new GUIDUnion("6c37b5363f7ef7844881a301dca76572"),
			new GUIDUnion("8124ed58f064e384cb0314005b84be1b"),
			new GUIDUnion("ee69440bbce371e458daeba6eee12a49")
		};

		private static readonly MethodInfo _getGameObject = AccessTools.PropertyGetter(typeof(Component), "gameObject") ?? throw new ArgumentNullException("get_gameObject", "gameObject property getter was not found");

		private static readonly MethodInfo _updateIntervaled = AccessTools.Method(_carryableAttractorType, "UpdateIntervaled", (Type[])null, (Type[])null) ?? throw new ArgumentNullException("UpdateIntervaled", "UpdateIntervaled method was not found");

		private static readonly ConstructorInfo _actionContructor = AccessTools.Constructor(typeof(Action), new Type[2]
		{
			typeof(object),
			typeof(IntPtr)
		}, false);

		private static readonly CodeMatch[] _itemSearchIntervalCodeMatches = (CodeMatch[])(object)new CodeMatch[8]
		{
			new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
			new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.25f, (string)null),
			new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
			new CodeMatch((OpCode?)OpCodes.Call, (object)_getGameObject, (string)null),
			new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
			new CodeMatch((OpCode?)OpCodes.Ldftn, (object)_updateIntervaled, (string)null),
			new CodeMatch((OpCode?)OpCodes.Newobj, (object)_actionContructor, (string)null),
			new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.5f, (string)null)
		};

		public override string DisplayName => "Better Scoop";

		public override Version Version => PluginInfo.Version;

		public override string Id => "Maverik-BetterScoop";

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CarryableAttractor), "Awake")]
		private static void CarryableAttractorAwakePrefix(CarryableAttractor __instance)
		{
			CarryableAttractor scoop = __instance;
			if (!PhotonNetwork.IsMasterClient)
			{
				return;
			}
			MavsBepInExPlugin<BetterScoop>.LoggedExceptions((Action)delegate
			{
				SetExtensions.Set<CarryableAttractor, ModifiableFloat>(scoop, (Expression<Func<CarryableAttractor, ModifiableFloat>>)((CarryableAttractor x) => x.MaxRange), (Func<ModifiableFloat, ModifiableFloat>)((ModifiableFloat _) => ModifiableFloat.op_Implicit(MavsBepInExPlugin<BetterScoop, PluginConfiguration>.Configuration.MaxRange)), (ManualLogSource)(object)MavsBepInExPlugin<BetterScoop>.Logger, "MaxRange");
				SetExtensions.Set<CarryableAttractor, float>(scoop, (MemberInfo)_coneAngle, (Func<float, float>)((float _) => MavsBepInExPlugin<BetterScoop, PluginConfiguration>.Configuration.ConeAngle), (ManualLogSource)(object)MavsBepInExPlugin<BetterScoop>.Logger, "ConeAngle");
				SetExtensions.Set<CarryableAttractor, float>(scoop, (MemberInfo)_catchRadius, (Func<float, float>)((float _) => MavsBepInExPlugin<BetterScoop, PluginConfiguration>.Configuration.CatchRadius), (ManualLogSource)(object)MavsBepInExPlugin<BetterScoop>.Logger, "CatchRadius");
				SetExtensions.Set<CarryableAttractor, float>(scoop, (MemberInfo)_inheritVelocityValue, (Func<float, float>)((float _) => MavsBepInExPlugin<BetterScoop, PluginConfiguration>.Configuration.InheritVelocityValue), (ManualLogSource)(object)MavsBepInExPlugin<BetterScoop>.Logger, "InheritVelocityValue");
				SetExtensions.Set<CarryableAttractor, ModifiableFloat>(scoop, (MemberInfo)_pullVelocity, (Func<ModifiableFloat, ModifiableFloat>)((ModifiableFloat _) => ModifiableFloat.op_Implicit(MavsBepInExPlugin<BetterScoop, PluginConfiguration>.Configuration.PullVelocity)), (ManualLogSource)(object)MavsBepInExPlugin<BetterScoop>.Logger, "PullVelocity");
				((ManualLogSource)MavsBepInExPlugin<BetterScoop>.Logger).LogMessage((object)"Scoop successfully supercharged!");
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CarryableAttractor), "GetPossibleItemsToAttrack")]
		private static List<AbstractCarryableObject> CarryableAttractorGetPossibleItemsToAttrackPostfix(List<AbstractCarryableObject> __result)
		{
			List<AbstractCarryableObject> __result2 = __result;
			if (__result2.Count != 0)
			{
				return MavsBepInExPlugin<BetterScoop>.LoggedExceptions<List<AbstractCarryableObject>>((Func<List<AbstractCarryableObject>>)delegate
				{
					if (!MavsBepInExPlugin<BetterScoop, PluginConfiguration>.Configuration.PullMissionItems)
					{
						__result2.RemoveAll((AbstractCarryableObject x) => _assetGuidBlacklist.Contains(((AbstractCloneStarObject)x).assetGuid));
					}
					foreach (AbstractCarryableObject item in __result2)
					{
						item.UseCollision = true;
					}
					return __result2;
				}, (List<AbstractCarryableObject>)null);
			}
			return __result2;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(CarryableAttractor), "SubscribeAsMaster")]
		private static IEnumerable<CodeInstruction> CarryableAttractorSubscribeAsMasterTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			IEnumerable<CodeInstruction> instructions2 = instructions;
			return MavsBepInExPlugin<BetterScoop>.LoggedExceptions<IEnumerable<CodeInstruction>>((Func<IEnumerable<CodeInstruction>>)delegate
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				PluginConfiguration pluginConfiguration = new PluginConfiguration();
				pluginConfiguration.LoadFrom(((BaseUnityPlugin)new BetterScoop()).Config);
				((ManualLogSource)MavsBepInExPlugin<BetterScoop>.Logger).LogDebug((object)$"Config value: {pluginConfiguration.ItemSearchInterval}");
				IEnumerable<CodeInstruction> result = new CodeMatcher(instructions2, (ILGenerator)null).MatchForward(false, _itemSearchIntervalCodeMatches).ThrowIfInvalid("Code sequence could not be found for CarryableAttractor.SubscribeAsMaster patching").Advance(1)
					.SetOperandAndAdvance((object)pluginConfiguration.ItemSearchInterval)
					.Advance(5)
					.SetOperandAndAdvance((object)pluginConfiguration.ItemSearchInitialDelay)
					.InstructionEnumeration();
				((ManualLogSource)MavsBepInExPlugin<BetterScoop>.Logger).LogInfo((object)$"CarryableAttractor.ItemSearchInterval patched from 0.25f to {pluginConfiguration.ItemSearchInterval}f");
				((ManualLogSource)MavsBepInExPlugin<BetterScoop>.Logger).LogInfo((object)$"CarryableAttractor.ItemSearchInitialDelay patched from 0.5f to {pluginConfiguration.ItemSearchInitialDelay}f");
				return result;
			}, (IEnumerable<CodeInstruction>)null);
		}
	}
	internal sealed class PluginConfiguration : ISupportsConfigFile
	{
		public ulong SettingsVersion { get; set; }

		public bool PullMissionItems { get; set; }

		public float ItemSearchInterval { get; set; } = 0.25f;


		public float ItemSearchInitialDelay { get; set; } = 0.5f;


		public float ConeAngle { get; set; } = 90f;


		public float MaxRange { get; set; } = 200f;


		public float PullVelocity { get; set; } = 15f;


		public float CatchRadius { get; set; } = 3f;


		public float InheritVelocityValue { get; set; } = 0.85f;


		public void LoadFrom(ConfigFile config)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//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_00d0: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01d9: 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_01eb: Expected O, but got Unknown
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Expected O, but got Unknown
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Expected O, but got Unknown
			MaxRange = config.Bind<float>("Config", "MaxRange", 750f, new ConfigDescription("Determines maximum range of the scoop in meters. Game default is 200 meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(200f, 1000f), Array.Empty<object>())).Value;
			ItemSearchInterval = config.Bind<float>("Config", "ItemSearchInterval", 0.1f, new ConfigDescription("Determines how frequently scoop checks for loot per second. Game default interval is 0.25 seconds", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.25f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} })).Value;
			ItemSearchInitialDelay = config.Bind<float>("Config", "ItemSearchInitialDelay", 0.1f, new ConfigDescription("Determines how quickly the scoop starts working once it gets turned on. Game default delay is 0.5 seconds", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.5f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} })).Value;
			ConeAngle = config.Bind<float>("Config", "ConeAngle", 165f, new ConfigDescription("Determines how wide the cone that extends to the max range is. This is the maximum cone angle and will get restricted by collision with things like the hull or thrusters blocking line of sight. Game default is 90 degrees.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(90f, 180f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} })).Value;
			PullVelocity = config.Bind<float>("Config", "PullVelocity", 150f, new ConfigDescription("Determines how quickly the items travel to the scoop once linked. Game default is 15 meters per second", (AcceptableValueBase)(object)new AcceptableValueRange<float>(Mathf.Max(50f, MaxRange / 5f), Mathf.Min(250f, MaxRange / 3f)), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} })).Value;
			InheritVelocityValue = config.Bind<float>("Config", "InheritVelocityValue", 0.01f, new ConfigDescription("Determines how much of the ship velocity is transferred to loot before scoop starts accelerating it towards itself. Game default is 0.85 or 85%.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 0.85f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} })).Value;
			CatchRadius = config.Bind<float>("Config", "CatchRadius", 9f, new ConfigDescription("Determines when the item is considered to be close enough to just dock into the scoop. Game default is 3 meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(3f, 9f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true,
				ReadOnly = true
			} })).Value;
			PullMissionItems = config.Bind<bool>("Config", "PullMissionItems", false, "This setting controls if the scoop should pull mission items like power fuses & oxygen tank").Value;
		}
	}
	[CompilerGenerated]
	public static class PluginInfo
	{
		public const string PackageId = "Maverik-BetterScoop";

		public const string Title = "Better Scoop";

		public const string VersionString = "0.0.5";

		public static Version Version = Version.Parse("0.0.5");
	}
}