using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using IBelieveICanFly.Patches;
using IBelieveICanFly.Registration;
using ItemManager;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using PieceManager;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("IBelieveICanFly")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Yggdrah")]
[assembly: AssemblyProduct("IBelieveICanFly")]
[assembly: AssemblyCopyright("Copyright \ufffd  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("E0E2F92E-557C-4A05-9D89-AA92A0BD75C4")]
[assembly: AssemblyFileVersion("1.0.5")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.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 IBelieveICanFly
{
	[BepInPlugin("Yggdrah.IBelieveICanFly", "IBelieveICanFly", "1.0.5")]
	public class IBelieveICanFlyPlugin : BaseUnityPlugin
	{
		private class ConfigurationManagerAttributes
		{
			public int? Order;

			public bool? Browsable;

			public string? Category;

			public Action<ConfigEntryBase>? CustomDrawer;
		}

		private class AcceptableShortcuts : AcceptableValueBase
		{
			public AcceptableShortcuts()
				: base(typeof(KeyboardShortcut))
			{
			}

			public override object Clamp(object value)
			{
				return value;
			}

			public override bool IsValid(object value)
			{
				return true;
			}

			public override string ToDescriptionString()
			{
				return "# Acceptable values: " + string.Join(", ", UnityInput.Current.SupportedKeyCodes);
			}
		}

		internal const string ModName = "IBelieveICanFly";

		internal const string ModVersion = "1.0.5";

		internal const string Author = "Yggdrah";

		private const string ModGUID = "Yggdrah.IBelieveICanFly";

		private static readonly string ConfigFileName = "Yggdrah.IBelieveICanFly.cfg";

		private static readonly string ConfigFileFullPath;

		internal static string ConnectionError;

		private readonly Harmony _harmony = new Harmony("Yggdrah.IBelieveICanFly");

		internal static IBelieveICanFlyPlugin? context;

		public static readonly ManualLogSource IBelieveICanFlyLogger;

		private static readonly ConfigSync ConfigSync;

		private static readonly Dictionary<string, AssetBundle> _assetBundleCache;

		public const string bundleName = "ibelieveicanfly";

		private static ConfigEntry<bool>? _serverConfigLocked;

		public void Awake()
		{
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			context = this;
			_serverConfigLocked = config("01 - ServerSync", "01 - Lock Configuration", value: true, "Whether to enable or disable if the configuration is locked in which only server admins can change");
			ConfigSync.AddLockingConfigEntry<bool>(_serverConfigLocked);
			GetAssetBundle("ibelieveicanfly");
			Config.RegisterAllConfigs(((BaseUnityPlugin)this).Config, "Yggdrah.IBelieveICanFly");
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			SetupWatcher();
			GliderSystem.Initialize();
			IBelieveICanFly.Registration.Item.RegisterAll("ibelieveicanfly");
			if (saveOnConfigSet)
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
				((BaseUnityPlugin)this).Config.Save();
			}
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
			GliderSystem.OnModUnload();
			GliderSystem.CleanupRemotePlayerGliders();
		}

		public static AssetBundle? GetAssetBundle(string filename)
		{
			string filename2 = filename;
			if (_assetBundleCache.TryGetValue(filename2, out AssetBundle value))
			{
				return value;
			}
			AssetBundle val = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle a) => ((Object)a).name == filename2));
			if ((Object)(object)val != (Object)null)
			{
				_assetBundleCache[filename2] = val;
				return val;
			}
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(filename2));
				using Stream stream = executingAssembly.GetManifestResourceStream(name);
				AssetBundle val2 = AssetBundle.LoadFromStream(stream);
				_assetBundleCache[filename2] = val2;
				return val2;
			}
			catch (Exception)
			{
				return null;
			}
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (File.Exists(ConfigFileFullPath))
			{
				((BaseUnityPlugin)this).Config.Reload();
			}
		}

		internal ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			SyncedConfigEntry<T> syncedConfigEntry = ConfigSync.AddConfigEntry<T>(val2);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		internal ConfigEntry<T> config<T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		static IBelieveICanFlyPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			IBelieveICanFlyLogger = Logger.CreateLogSource("IBelieveICanFly");
			ConfigSync = new ConfigSync("Yggdrah.IBelieveICanFly")
			{
				DisplayName = "IBelieveICanFly",
				CurrentVersion = "1.0.5",
				MinimumRequiredVersion = "1.0.5",
				ModRequired = true
			};
			_assetBundleCache = new Dictionary<string, AssetBundle>();
		}
	}
	public static class KeyboardExtensions
	{
		public static bool IsKeyDown(this KeyboardShortcut shortcut)
		{
			//IL_0003: 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)
			return (int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
		}

		public static bool IsKeyHeld(this KeyboardShortcut shortcut)
		{
			//IL_0003: 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)
			return (int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			peer.m_rpc.Register<ZPackage>("IBelieveICanFly_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_IBelieveICanFly_Version);
			ZPackage val = new ZPackage();
			val.Write("1.0.5");
			peer.m_rpc.Invoke("IBelieveICanFly_VersionCheck", new object[1] { val });
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	public static class VerifyClient
	{
		private static bool Prefix(ZRpc rpc, ZPackage pkg, ref ZNet __instance)
		{
			if (!__instance.IsServer() || RpcHandlers.ValidatedPeers.Contains(rpc))
			{
				return true;
			}
			rpc.Invoke("Error", new object[1] { 3 });
			return false;
		}

		private static void Postfix(ZNet __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "RequestAdminSync", new object[1] { (object)new ZPackage() });
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	public class ShowConnectionError
	{
		private static void Postfix(FejdStartup __instance)
		{
			if (__instance.m_connectionFailedPanel.activeSelf)
			{
				__instance.m_connectionFailedError.fontSizeMax = 25f;
				__instance.m_connectionFailedError.fontSizeMin = 15f;
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + IBelieveICanFlyPlugin.ConnectionError;
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (__instance.IsServer())
			{
				RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	public static class RpcHandlers
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void RPC_IBelieveICanFly_Version(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			if (text != "1.0.5")
			{
				IBelieveICanFlyPlugin.ConnectionError = "IBelieveICanFly Installed: 1.0.5\n Needed: " + text;
				if (ZNet.instance.IsServer())
				{
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (ZNet.instance.IsServer())
			{
				ValidatedPeers.Add(rpc);
			}
		}
	}
}
namespace IBelieveICanFly.Registration
{
	public static class Config
	{
		public static ConfigEntry<bool> ToggleMode { get; private set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static void RegisterAllConfigs(ConfigFile config, string modGuid)
		{
			if ((Object)(object)IBelieveICanFlyPlugin.context != (Object)null)
			{
				ToggleMode = IBelieveICanFlyPlugin.context.config("02 - General Settings", "01 - Toggle Mode", value: true, "Whether to enable or disable if pressing Space will toggle gliding. When disabled, hold Space to glide.");
				RegisterWings1();
				RegisterWings2();
				RegisterWings3();
				RegisterWings4();
				RegisterWings5();
				RegisterWings6();
			}
		}

		private static void RegisterWings1()
		{
			Wings1Enabled = IBelieveICanFlyPlugin.context.config("02.01 - Wings 1", "01 - Enabled", value: true, "Whether to enable or disable Wings 1. When enabled, this wings configuration will be active.");
			Wings1ItemName = IBelieveICanFlyPlugin.context.config("02.01 - Wings 1", "02 - Item Name", "Glider_BackPack_Ygg", "Item prefab name that triggers Wings 1. Use vanilla item names like 'SwordIron' or custom item names.");
			Wings1VisualPrefab = IBelieveICanFlyPlugin.context.config("02.01 - Wings 1", "03 - Visual Prefab Override", "DragonWings_Ygg", "Optional: Override the visual prefab shown when gliding. If empty, uses the trigger item's model. Use this to show wings while having a ring/amulet as the trigger item.");
			Wings1CheckRightHand = IBelieveICanFlyPlugin.context.config("02.02 - Wings 1", "01 - Check Right Hand", value: false, "Whether to enable or disable checking the right hand slot for Wings 1 item.");
			Wings1CheckLeftHand = IBelieveICanFlyPlugin.context.config("02.02 - Wings 1", "02 - Check Left Hand", value: false, "Whether to enable or disable checking the left hand slot for Wings 1 item.");
			Wings1CheckUtility = IBelieveICanFlyPlugin.context.config("02.02 - Wings 1", "03 - Check Utility Slot", value: true, "Whether to enable or disable checking the utility/belt slot for Wings 1 item.");
			Wings1UseFallReset = IBelieveICanFlyPlugin.context.config("02.02 - Wings 1", "04 - Prevent Fall Damage", value: true, "Whether to enable or disable fall damage when landing after gliding with Wings 1.");
			Wings1Animation = IBelieveICanFlyPlugin.context.config("02.02 - Wings 1", "05 - Use Animation", value: true, "Whether to enable or disable using animation while gliding with Wings 1.");
			Wings1MinActivationFallSpeed = IBelieveICanFlyPlugin.context.config("02.03 - Wings 1", "01 - Min Activation Fall Speed", -0.5f, "Prevent glide trigger if you barely left ground for Wings 1.");
			Wings1ForwardSpeed = IBelieveICanFlyPlugin.context.config("02.03 - Wings 1", "02 - Max Forward Speed", 10f, "Maximum forward speed while gliding with Wings 1.");
			Wings1ForwardForce = IBelieveICanFlyPlugin.context.config("02.03 - Wings 1", "03 - Forward Force", 5f, "Forward acceleration while gliding with Wings 1.");
			Wings1DescentSpeed = IBelieveICanFlyPlugin.context.config("02.03 - Wings 1", "04 - Max Descent Speed", -4f, "How fast you can fall while gliding with Wings 1 (more negative = faster fall).");
			Wings1AirTurnSpeed = IBelieveICanFlyPlugin.context.config("02.03 - Wings 1", "05 - Air Turn Speed", 120f, "Yaw control while gliding with Wings 1 (deg/sec).");
			Wings1LateralDamp = IBelieveICanFlyPlugin.context.config("02.03 - Wings 1", "06 - Lateral Damping", 0.15f, "Slight damping to stabilize lateral drift for Wings 1.");
			Wings1GroundProbeDistance = IBelieveICanFlyPlugin.context.config("02.03 - Wings 1", "07 - Ground Probe Distance", 2.5f, "Start cushioning this far from ground for Wings 1.");
			Wings1CushionDescentSpeed = IBelieveICanFlyPlugin.context.config("02.03 - Wings 1", "08 - Cushion Descent Speed", -0.7f, "Final descent cap near ground for Wings 1.");
			Wings1CushionLerp = IBelieveICanFlyPlugin.context.config("02.03 - Wings 1", "09 - Cushion Lerp", 0.6f, "How quickly we clamp toward the cushion speed for Wings 1.");
			Wings1TiltMaxPitch = IBelieveICanFlyPlugin.context.config("02.04 - Wings 1", "01 - Max Pitch", 25f, "Maximum pitch angle (nose up/down) in degrees for Wings 1.");
			Wings1TiltMaxRoll = IBelieveICanFlyPlugin.context.config("02.04 - Wings 1", "02 - Max Roll", 35f, "Maximum roll angle (banking) in degrees for Wings 1.");
			Wings1TiltPitchSmoothTime = IBelieveICanFlyPlugin.context.config("02.04 - Wings 1", "03 - Pitch Smooth Time", 0.15f, "How quickly pitch changes (lower = faster response) for Wings 1.");
			Wings1TiltRollSmoothTime = IBelieveICanFlyPlugin.context.config("02.04 - Wings 1", "04 - Roll Smooth Time", 0.1f, "How quickly roll/banking changes (lower = faster response) for Wings 1.");
			Wings1UpDownOffset = IBelieveICanFlyPlugin.context.config("02.05 - Wings 1", "01 - Up/Down Offset", 0.3f, "Adjust Wings 1 vertical position on the player's back. Higher values move it up.");
			Wings1LeftRightOffset = IBelieveICanFlyPlugin.context.config("02.05 - Wings 1", "02 - Left/Right Offset", 0f, "Adjust Wings 1 horizontal position on the player's back. Positive values move it to the right.");
			Wings1ForwardBackOffset = IBelieveICanFlyPlugin.context.config("02.05 - Wings 1", "03 - Forward/Back Offset", 0.7f, "Adjust Wings 1 position front-to-back on the player. Negative values move it backward.");
			Wings1RotationX = IBelieveICanFlyPlugin.context.config("02.06 - Wings 1", "01 - X Rotation", 10f, "Adjust Wings 1 pitch rotation in degrees. Controls tilt forward/backward.");
			Wings1RotationY = IBelieveICanFlyPlugin.context.config("02.06 - Wings 1", "02 - Y Rotation", 160f, "Adjust Wings 1 yaw rotation in degrees. Controls left/right facing.");
			Wings1RotationZ = IBelieveICanFlyPlugin.context.config("02.06 - Wings 1", "03 - Z Rotation", 0f, "Adjust Wings 1 roll rotation in degrees. Controls tilt to sides.");
			Wings1Scale = IBelieveICanFlyPlugin.context.config("02.06 - Wings 1", "04 - Scale", 0.3f, "Adjust the overall size of Wings 1. 1.0 is normal size.");
			Wings1SFX = IBelieveICanFlyPlugin.context.config("02.07 - Wings 1", "01 - SFX", value: true, "Whether to enable or disable SFX when gliding with Wings 1.");
			Wings1AttachSFXToPlayer = IBelieveICanFlyPlugin.context.config("02.07 - Wings 1", "02 - Attach SFX To Player", value: false, "Whether to enable or disable SFX for Wings 1 will be attached to the player and follow their movement.");
			Wings1StartSFX = IBelieveICanFlyPlugin.context.config("02.07 - Wings 1", "03 - Start SFX", "sfx_flap_glider_Ygg", "Sound effect to play when starting to glide with Wings 1. Use vanilla sound effect names.");
			Wings1LoopSFX = IBelieveICanFlyPlugin.context.config("02.07 - Wings 1", "04 - Loop SFX", "", "Sound effect to play continuously while gliding with Wings 1. Use vanilla sound effect names.");
			Wings1StopSFX = IBelieveICanFlyPlugin.context.config("02.07 - Wings 1", "05 - Stop SFX", "sfx_flap_glider_Ygg", "Sound effect to play when stopping gliding with Wings 1. Use vanilla sound effect names.");
			Wings1VFX = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "01 - VFX", value: false, "Whether to enable or disable VFX when gliding with Wings 1.");
			Wings1AttachEffectsToPlayer = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "02 - Attach VFX To Player", value: false, "Whether to enable or disable VFX for Wings 1 will be attached to the player and follow their movement.");
			Wings1StartVFX = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "03 - Start VFX", "", "Visual effect to play when starting to glide with Wings 1. Use vanilla VFX names.");
			Wings1LoopVFX = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "04 - Loop VFX", "", "Visual effect to play continuously while gliding with Wings 1. Use vanilla VFX names.");
			Wings1StopVFX = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "05 - Stop VFX", "", "Visual effect to play when stopping gliding with Wings 1. Use vanilla VFX names.");
			Wings1VFXPosition = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "06 - VFX Position", "Root", "Position for VFX for Wings 1: 'Root' (at player's feet), 'Middle' (at player's center), or 'Custom' (use custom coordinates).");
			Wings1VFXScale = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "07 - VFX Scale", 1f, "Scale factor for VFX for Wings 1. 1.0 is normal size.");
			Wings1VFXCustomX = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "08 - Custom X Offset", 0f, "X offset for custom VFX position for Wings 1 (only used when VFX Position is set to 'Custom').");
			Wings1VFXCustomY = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "09 - Custom Y Offset", 1f, "Y offset for custom VFX position for Wings 1 (only used when VFX Position is set to 'Custom').");
			Wings1VFXCustomZ = IBelieveICanFlyPlugin.context.config("02.08 - Wings 1", "10 - Custom Z Offset", 0f, "Z offset for custom VFX position for Wings 1 (only used when VFX Position is set to 'Custom').");
		}

		private static void RegisterWings2()
		{
			Wings2Enabled = IBelieveICanFlyPlugin.context.config("03.01 - Wings 2", "01 - Enabled", value: true, "Whether to enable or disable Wings 2. When enabled, this wings configuration will be active.");
			Wings2ItemName = IBelieveICanFlyPlugin.context.config("03.01 - Wings 2", "02 - Item Name", "Glider_BackPack_DragonModer_Ygg", "Item prefab name that triggers Wings 2. Use vanilla item names like 'SwordBronze' or custom item names.");
			Wings2VisualPrefab = IBelieveICanFlyPlugin.context.config("03.01 - Wings 2", "03 - Visual Prefab Override", "DragonWings_Ygg1", "Optional: Override the visual prefab shown when gliding. If empty, uses the trigger item's model. Use this to show wings while having a ring/amulet as the trigger item.");
			Wings2CheckRightHand = IBelieveICanFlyPlugin.context.config("03.02 - Wings 2", "01 - Check Right Hand", value: false, "Whether to enable or disable checking the right hand slot for Wings 2 item.");
			Wings2CheckLeftHand = IBelieveICanFlyPlugin.context.config("03.02 - Wings 2", "02 - Check Left Hand", value: false, "Whether to enable or disable checking the left hand slot for Wings 2 item.");
			Wings2CheckUtility = IBelieveICanFlyPlugin.context.config("03.02 - Wings 2", "03 - Check Utility Slot", value: true, "Whether to enable or disable checking the utility/belt slot for Wings 2 item.");
			Wings2UseFallReset = IBelieveICanFlyPlugin.context.config("03.02 - Wings 2", "04 - Prevent Fall Damage", value: true, "Whether to enable or disable fall damage when landing after gliding with Wings 2.");
			Wings2Animation = IBelieveICanFlyPlugin.context.config("03.02 - Wings 2", "05 - Use Animation", value: true, "Whether to enable or disable using animation while gliding with Wings 2.");
			Wings2MinActivationFallSpeed = IBelieveICanFlyPlugin.context.config("03.03 - Wings 2", "01 - Min Activation Fall Speed", -0.5f, "Prevent glide trigger if you barely left ground for Wings 2.");
			Wings2ForwardSpeed = IBelieveICanFlyPlugin.context.config("03.03 - Wings 2", "02 - Max Forward Speed", 12f, "Maximum forward speed while gliding with Wings 2.");
			Wings2ForwardForce = IBelieveICanFlyPlugin.context.config("03.03 - Wings 2", "03 - Forward Force", 8f, "Forward acceleration while gliding with Wings 2.");
			Wings2DescentSpeed = IBelieveICanFlyPlugin.context.config("03.03 - Wings 2", "04 - Max Descent Speed", -3.5f, "How fast you can fall while gliding with Wings 2 (more negative = faster fall).");
			Wings2AirTurnSpeed = IBelieveICanFlyPlugin.context.config("03.03 - Wings 2", "05 - Air Turn Speed", 100f, "Yaw control while gliding with Wings 2 (deg/sec).");
			Wings2LateralDamp = IBelieveICanFlyPlugin.context.config("03.03 - Wings 2", "06 - Lateral Damping", 0.15f, "Slight damping to stabilize lateral drift for Wings 2.");
			Wings2GroundProbeDistance = IBelieveICanFlyPlugin.context.config("03.03 - Wings 2", "07 - Ground Probe Distance", 2.5f, "Start cushioning this far from ground for Wings 2.");
			Wings2CushionDescentSpeed = IBelieveICanFlyPlugin.context.config("03.03 - Wings 2", "08 - Cushion Descent Speed", -0.7f, "Final descent cap near ground for Wings 2.");
			Wings2CushionLerp = IBelieveICanFlyPlugin.context.config("03.03 - Wings 2", "09 - Cushion Lerp", 0.6f, "How quickly we clamp toward the cushion speed for Wings 2.");
			Wings2TiltMaxPitch = IBelieveICanFlyPlugin.context.config("03.04 - Wings 2", "01 - Max Pitch", 25f, "Maximum pitch angle (nose up/down) in degrees for Wings 2.");
			Wings2TiltMaxRoll = IBelieveICanFlyPlugin.context.config("03.04 - Wings 2", "02 - Max Roll", 35f, "Maximum roll angle (banking) in degrees for Wings 2.");
			Wings2TiltPitchSmoothTime = IBelieveICanFlyPlugin.context.config("03.04 - Wings 2", "03 - Pitch Smooth Time", 0.15f, "How quickly pitch changes (lower = faster response) for Wings 2.");
			Wings2TiltRollSmoothTime = IBelieveICanFlyPlugin.context.config("03.04 - Wings 2", "04 - Roll Smooth Time", 0.1f, "How quickly roll/banking changes (lower = faster response) for Wings 2.");
			Wings2UpDownOffset = IBelieveICanFlyPlugin.context.config("03.05 - Wings 2", "01 - Up/Down Offset", -0.18f, "Adjust Wings 2 vertical position on the player's back. Higher values move it up.");
			Wings2LeftRightOffset = IBelieveICanFlyPlugin.context.config("03.05 - Wings 2", "02 - Left/Right Offset", 0f, "Adjust Wings 2 horizontal position on the player's back. Positive values move it to the right.");
			Wings2ForwardBackOffset = IBelieveICanFlyPlugin.context.config("03.05 - Wings 2", "03 - Forward/Back Offset", -0.15f, "Adjust Wings 2 position front-to-back on the player. Negative values move it backward.");
			Wings2RotationX = IBelieveICanFlyPlugin.context.config("03.06 - Wings 2", "01 - X Rotation", 0f, "Adjust Wings 2 pitch rotation in degrees. Controls tilt forward/backward.");
			Wings2RotationY = IBelieveICanFlyPlugin.context.config("03.06 - Wings 2", "02 - Y Rotation", 0f, "Adjust Wings 2 yaw rotation in degrees. Controls left/right facing.");
			Wings2RotationZ = IBelieveICanFlyPlugin.context.config("03.06 - Wings 2", "03 - Z Rotation", 0f, "Adjust Wings 2 roll rotation in degrees. Controls tilt to sides.");
			Wings2Scale = IBelieveICanFlyPlugin.context.config("03.06 - Wings 2", "04 - Scale", 0.3f, "Adjust the overall size of Wings 2. 1.0 is normal size.");
			Wings2SFX = IBelieveICanFlyPlugin.context.config("03.07 - Wings 2", "01 - SFX", value: true, "Whether to enable or disable SFX when gliding with Wings 2.");
			Wings2AttachSFXToPlayer = IBelieveICanFlyPlugin.context.config("03.07 - Wings 2", "02 - Attach SFX To Player", value: false, "Whether to enable or disable SFX for Wings 2 will be attached to the player and follow their movement.");
			Wings2StartSFX = IBelieveICanFlyPlugin.context.config("03.07 - Wings 2", "03 - Start SFX", "sfx_flap_glider_Ygg", "Sound effect to play when starting to glide with Wings 2. Use vanilla sound effect names.");
			Wings2LoopSFX = IBelieveICanFlyPlugin.context.config("03.07 - Wings 2", "04 - Loop SFX", "", "Sound effect to play continuously while gliding with Wings 2. Use vanilla sound effect names.");
			Wings2StopSFX = IBelieveICanFlyPlugin.context.config("03.07 - Wings 2", "05 - Stop SFX", "sfx_flap_glider_Ygg", "Sound effect to play when stopping gliding with Wings 2. Use vanilla sound effect names.");
			Wings2VFX = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "01 - VFX", value: false, "Whether to enable or disable VFX when gliding with Wings 2.");
			Wings2AttachEffectsToPlayer = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "02 - Attach VFX To Player", value: false, "Whether to enable or disable VFX for Wings 2 will be attached to the player and follow their movement.");
			Wings2StartVFX = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "03 - Start VFX", "", "Visual effect to play when starting to glide with Wings 2. Use vanilla VFX names.");
			Wings2LoopVFX = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "04 - Loop VFX", "", "Visual effect to play continuously while gliding with Wings 2. Use vanilla VFX names.");
			Wings2StopVFX = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "05 - Stop VFX", "", "Visual effect to play when stopping gliding with Wings 2. Use vanilla VFX names.");
			Wings2VFXPosition = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "06 - VFX Position", "Root", "Position for VFX for Wings 2: 'Root' (at player's feet), 'Middle' (at player's center), or 'Custom' (use custom coordinates).");
			Wings2VFXScale = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "07 - VFX Scale", 1f, "Scale factor for VFX for Wings 2. 1.0 is normal size.");
			Wings2VFXCustomX = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "08 - Custom X Offset", 0f, "X offset for custom VFX position for Wings 2 (only used when VFX Position is set to 'Custom').");
			Wings2VFXCustomY = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "09 - Custom Y Offset", 1f, "Y offset for custom VFX position for Wings 2 (only used when VFX Position is set to 'Custom').");
			Wings2VFXCustomZ = IBelieveICanFlyPlugin.context.config("03.08 - Wings 2", "10 - Custom Z Offset", 0f, "Z offset for custom VFX position for Wings 2 (only used when VFX Position is set to 'Custom').");
		}

		private static void RegisterWings3()
		{
			Wings3Enabled = IBelieveICanFlyPlugin.context.config("04.01 - Wings 3", "01 - Enabled", value: true, "Whether to enable or disable Wings 3. When enabled, this wings configuration will be active.");
			Wings3ItemName = IBelieveICanFlyPlugin.context.config("04.01 - Wings 3", "02 - Item Name", "Glider_BackPack_BlackDragon_Ygg", "Item prefab name that triggers Wings 3. Use vanilla item names like 'SwordBlackmetal' or custom item names.");
			Wings3VisualPrefab = IBelieveICanFlyPlugin.context.config("04.01 - Wings 3", "03 - Visual Prefab Override", "DragonWings_Ygg2", "Optional: Override the visual prefab shown when gliding. If empty, uses the trigger item's model. Use this to show wings while having a ring/amulet as the trigger item.");
			Wings3CheckRightHand = IBelieveICanFlyPlugin.context.config("04.02 - Wings 3", "01 - Check Right Hand", value: false, "Whether to enable or disable checking the right hand slot for Wings 3 item.");
			Wings3CheckLeftHand = IBelieveICanFlyPlugin.context.config("04.02 - Wings 3", "02 - Check Left Hand", value: false, "Whether to enable or disable checking the left hand slot for Wings 3 item.");
			Wings3CheckUtility = IBelieveICanFlyPlugin.context.config("04.02 - Wings 3", "03 - Check Utility Slot", value: true, "Whether to enable or disable checking the utility/belt slot for Wings 3 item.");
			Wings3UseFallReset = IBelieveICanFlyPlugin.context.config("04.02 - Wings 3", "04 - Prevent Fall Damage", value: true, "Whether to enable or disable fall damage when landing after gliding with Wings 3.");
			Wings3Animation = IBelieveICanFlyPlugin.context.config("04.02 - Wings 3", "05 - Use Animation", value: true, "Whether to enable or disable using animation while gliding with Wings 3.");
			Wings3MinActivationFallSpeed = IBelieveICanFlyPlugin.context.config("04.03 - Wings 3", "01 - Min Activation Fall Speed", -0.5f, "Prevent glide trigger if you barely left ground for Wings 3.");
			Wings3ForwardSpeed = IBelieveICanFlyPlugin.context.config("04.03 - Wings 3", "02 - Max Forward Speed", 20f, "Maximum forward speed while gliding with Wings 3.");
			Wings3ForwardForce = IBelieveICanFlyPlugin.context.config("04.03 - Wings 3", "03 - Forward Force", 12f, "Forward acceleration while gliding with Wings 3.");
			Wings3DescentSpeed = IBelieveICanFlyPlugin.context.config("04.03 - Wings 3", "04 - Max Descent Speed", -2.5f, "How fast you can fall while gliding with Wings 3 (more negative = faster fall).");
			Wings3AirTurnSpeed = IBelieveICanFlyPlugin.context.config("04.03 - Wings 3", "05 - Air Turn Speed", 100f, "Yaw control while gliding with Wings 3 (deg/sec).");
			Wings3LateralDamp = IBelieveICanFlyPlugin.context.config("04.03 - Wings 3", "06 - Lateral Damping", 0.15f, "Slight damping to stabilize lateral drift for Wings 3.");
			Wings3GroundProbeDistance = IBelieveICanFlyPlugin.context.config("04.03 - Wings 3", "07 - Ground Probe Distance", 2.5f, "Start cushioning this far from ground for Wings 3.");
			Wings3CushionDescentSpeed = IBelieveICanFlyPlugin.context.config("04.03 - Wings 3", "08 - Cushion Descent Speed", -0.7f, "Final descent cap near ground for Wings 3.");
			Wings3CushionLerp = IBelieveICanFlyPlugin.context.config("04.03 - Wings 3", "09 - Cushion Lerp", 0.6f, "How quickly we clamp toward the cushion speed for Wings 3.");
			Wings3TiltMaxPitch = IBelieveICanFlyPlugin.context.config("04.04 - Wings 3", "01 - Max Pitch", 25f, "Maximum pitch angle (nose up/down) in degrees for Wings 3.");
			Wings3TiltMaxRoll = IBelieveICanFlyPlugin.context.config("04.04 - Wings 3", "02 - Max Roll", 35f, "Maximum roll angle (banking) in degrees for Wings 3.");
			Wings3TiltPitchSmoothTime = IBelieveICanFlyPlugin.context.config("04.04 - Wings 3", "03 - Pitch Smooth Time", 0.15f, "How quickly pitch changes (lower = faster response) for Wings 3.");
			Wings3TiltRollSmoothTime = IBelieveICanFlyPlugin.context.config("04.04 - Wings 3", "04 - Roll Smooth Time", 0.1f, "How quickly roll/banking changes (lower = faster response) for Wings 3.");
			Wings3UpDownOffset = IBelieveICanFlyPlugin.context.config("04.05 - Wings 3", "01 - Up/Down Offset", -0.1f, "Adjust Wings 3 vertical position on the player's back. Higher values move it up.");
			Wings3LeftRightOffset = IBelieveICanFlyPlugin.context.config("04.05 - Wings 3", "02 - Left/Right Offset", 0f, "Adjust Wings 3 horizontal position on the player's back. Positive values move it to the right.");
			Wings3ForwardBackOffset = IBelieveICanFlyPlugin.context.config("04.05 - Wings 3", "03 - Forward/Back Offset", -0.2f, "Adjust Wings 3 position front-to-back on the player. Negative values move it backward.");
			Wings3RotationX = IBelieveICanFlyPlugin.context.config("04.06 - Wings 3", "01 - X Rotation", 0f, "Adjust Wings 3 pitch rotation in degrees. Controls tilt forward/backward.");
			Wings3RotationY = IBelieveICanFlyPlugin.context.config("04.06 - Wings 3", "02 - Y Rotation", 0f, "Adjust Wings 3 yaw rotation in degrees. Controls left/right facing.");
			Wings3RotationZ = IBelieveICanFlyPlugin.context.config("04.06 - Wings 3", "03 - Z Rotation", 0f, "Adjust Wings 3 roll rotation in degrees. Controls tilt to sides.");
			Wings3Scale = IBelieveICanFlyPlugin.context.config("04.06 - Wings 3", "04 - Scale", 0.3f, "Adjust the overall size of Wings 3. 1.0 is normal size.");
			Wings3SFX = IBelieveICanFlyPlugin.context.config("04.07 - Wings 3", "01 - SFX", value: true, "Whether to enable or disable SFX when gliding with Wings 3.");
			Wings3AttachSFXToPlayer = IBelieveICanFlyPlugin.context.config("04.07 - Wings 3", "02 - Attach SFX To Player", value: false, "Whether to enable or disable SFX for Wings 3 will be attached to the player and follow their movement.");
			Wings3StartSFX = IBelieveICanFlyPlugin.context.config("04.07 - Wings 3", "03 - Start SFX", "sfx_flap_glider_Ygg", "Sound effect to play when starting to glide with Wings 3. Use vanilla sound effect names.");
			Wings3LoopSFX = IBelieveICanFlyPlugin.context.config("04.07 - Wings 3", "04 - Loop SFX", "sfx_flap_glider_Ygg", "Sound effect to play continuously while gliding with Wings 3. Use vanilla sound effect names.");
			Wings3StopSFX = IBelieveICanFlyPlugin.context.config("04.07 - Wings 3", "05 - Stop SFX", "sfx_flap_glider_Ygg", "Sound effect to play when stopping gliding with Wings 3. Use vanilla sound effect names.");
			Wings3VFX = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "01 - VFX", value: false, "Whether to enable or disable VFX when gliding with Wings 3.");
			Wings3AttachEffectsToPlayer = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "02 - Attach VFX To Player", value: false, "Whether to enable or disable VFX for Wings 3 will be attached to the player and follow their movement.");
			Wings3StartVFX = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "03 - Start VFX", "", "Visual effect to play when starting to glide with Wings 3. Use vanilla VFX names.");
			Wings3LoopVFX = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "04 - Loop VFX", "", "Visual effect to play continuously while gliding with Wings 3. Use vanilla VFX names.");
			Wings3StopVFX = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "05 - Stop VFX", "", "Visual effect to play when stopping gliding with Wings 3. Use vanilla VFX names.");
			Wings3VFXPosition = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "06 - VFX Position", "Root", "Position for VFX for Wings 3: 'Root' (at player's feet), 'Middle' (at player's center), or 'Custom' (use custom coordinates).");
			Wings3VFXScale = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "07 - VFX Scale", 1f, "Scale factor for VFX for Wings 3. 1.0 is normal size.");
			Wings3VFXCustomX = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "08 - Custom X Offset", 0f, "X offset for custom VFX position for Wings 3 (only used when VFX Position is set to 'Custom').");
			Wings3VFXCustomY = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "09 - Custom Y Offset", 1f, "Y offset for custom VFX position for Wings 3 (only used when VFX Position is set to 'Custom').");
			Wings3VFXCustomZ = IBelieveICanFlyPlugin.context.config("04.08 - Wings 3", "10 - Custom Z Offset", 0f, "Z offset for custom VFX position for Wings 3 (only used when VFX Position is set to 'Custom').");
		}

		private static void RegisterWings4()
		{
			Wings4Enabled = IBelieveICanFlyPlugin.context.config("05.01 - Wings 4", "01 - Enabled", value: true, "Whether to enable or disable Wings 4. When enabled, this wings configuration will be active.");
			Wings4ItemName = IBelieveICanFlyPlugin.context.config("05.01 - Wings 4", "02 - Item Name", "Glider_Gjall_BackPack_Ygg", "Item prefab name that triggers Wings 4. Use vanilla item names like 'SwordSilver' or custom item names.");
			Wings4VisualPrefab = IBelieveICanFlyPlugin.context.config("05.01 - Wings 4", "03 - Visual Prefab Override", "DragonWings_Ygg3", "Optional: Override the visual prefab shown when gliding. If empty, uses the trigger item's model. Use this to show wings while having a ring/amulet as the trigger item.");
			Wings4CheckRightHand = IBelieveICanFlyPlugin.context.config("05.02 - Wings 4", "01 - Check Right Hand", value: false, "Whether to enable or disable checking the right hand slot for Wings 4 item.");
			Wings4CheckLeftHand = IBelieveICanFlyPlugin.context.config("05.02 - Wings 4", "02 - Check Left Hand", value: false, "Whether to enable or disable checking the left hand slot for Wings 4 item.");
			Wings4CheckUtility = IBelieveICanFlyPlugin.context.config("05.02 - Wings 4", "03 - Check Utility Slot", value: true, "Whether to enable or disable checking the utility/belt slot for Wings 4 item.");
			Wings4UseFallReset = IBelieveICanFlyPlugin.context.config("05.02 - Wings 4", "04 - Prevent Fall Damage", value: true, "Whether to enable or disable fall damage when landing after gliding with Wings 4.");
			Wings4Animation = IBelieveICanFlyPlugin.context.config("05.02 - Wings 4", "05 - Use Animation", value: true, "Whether to enable or disable using animation while gliding with Wings 4.");
			Wings4MinActivationFallSpeed = IBelieveICanFlyPlugin.context.config("05.03 - Wings 4", "01 - Min Activation Fall Speed", -0.5f, "Prevent glide trigger if you barely left ground for Wings 4.");
			Wings4ForwardSpeed = IBelieveICanFlyPlugin.context.config("05.03 - Wings 4", "02 - Max Forward Speed", 6f, "Maximum forward speed while gliding with Wings 4.");
			Wings4ForwardForce = IBelieveICanFlyPlugin.context.config("05.03 - Wings 4", "03 - Forward Force", 11f, "Forward acceleration while gliding with Wings 4.");
			Wings4DescentSpeed = IBelieveICanFlyPlugin.context.config("05.03 - Wings 4", "04 - Max Descent Speed", -1f, "How fast you can fall while gliding with Wings 4 (more negative = faster fall).");
			Wings4AirTurnSpeed = IBelieveICanFlyPlugin.context.config("05.03 - Wings 4", "05 - Air Turn Speed", 130f, "Yaw control while gliding with Wings 4 (deg/sec).");
			Wings4LateralDamp = IBelieveICanFlyPlugin.context.config("05.03 - Wings 4", "06 - Lateral Damping", 0.15f, "Slight damping to stabilize lateral drift for Wings 4.");
			Wings4GroundProbeDistance = IBelieveICanFlyPlugin.context.config("05.03 - Wings 4", "07 - Ground Probe Distance", 2.5f, "Start cushioning this far from ground for Wings 4.");
			Wings4CushionDescentSpeed = IBelieveICanFlyPlugin.context.config("05.03 - Wings 4", "08 - Cushion Descent Speed", -0.7f, "Final descent cap near ground for Wings 4.");
			Wings4CushionLerp = IBelieveICanFlyPlugin.context.config("05.03 - Wings 4", "09 - Cushion Lerp", 0.6f, "How quickly we clamp toward the cushion speed for Wings 4.");
			Wings4TiltMaxPitch = IBelieveICanFlyPlugin.context.config("05.04 - Wings 4", "01 - Max Pitch", 25f, "Maximum pitch angle (nose up/down) in degrees for Wings 4.");
			Wings4TiltMaxRoll = IBelieveICanFlyPlugin.context.config("05.04 - Wings 4", "02 - Max Roll", 35f, "Maximum roll angle (banking) in degrees for Wings 4.");
			Wings4TiltPitchSmoothTime = IBelieveICanFlyPlugin.context.config("05.04 - Wings 4", "03 - Pitch Smooth Time", 0.15f, "How quickly pitch changes (lower = faster response) for Wings 4.");
			Wings4TiltRollSmoothTime = IBelieveICanFlyPlugin.context.config("05.04 - Wings 4", "04 - Roll Smooth Time", 0.1f, "How quickly roll/banking changes (lower = faster response) for Wings 4.");
			Wings4UpDownOffset = IBelieveICanFlyPlugin.context.config("05.05 - Wings 4", "01 - Up/Down Offset", -2f, "Adjust Wings 4 vertical position on the player's back. Higher values move it up.");
			Wings4LeftRightOffset = IBelieveICanFlyPlugin.context.config("05.05 - Wings 4", "02 - Left/Right Offset", 0f, "Adjust Wings 4 horizontal position on the player's back. Positive values move it to the right.");
			Wings4ForwardBackOffset = IBelieveICanFlyPlugin.context.config("05.05 - Wings 4", "03 - Forward/Back Offset", -5f, "Adjust Wings 4 position front-to-back on the player. Negative values move it backward.");
			Wings4RotationX = IBelieveICanFlyPlugin.context.config("05.06 - Wings 4", "01 - X Rotation", 70f, "Adjust Wings 4 pitch rotation in degrees. Controls tilt forward/backward.");
			Wings4RotationY = IBelieveICanFlyPlugin.context.config("05.06 - Wings 4", "02 - Y Rotation", 0f, "Adjust Wings 4 yaw rotation in degrees. Controls left/right facing.");
			Wings4RotationZ = IBelieveICanFlyPlugin.context.config("05.06 - Wings 4", "03 - Z Rotation", 0f, "Adjust Wings 4 roll rotation in degrees. Controls tilt to sides.");
			Wings4Scale = IBelieveICanFlyPlugin.context.config("05.06 - Wings 4", "04 - Scale", 0.4f, "Adjust the overall size of Wings 4. 1.0 is normal size.");
			Wings4SFX = IBelieveICanFlyPlugin.context.config("05.07 - Wings 4", "01 - SFX", value: true, "Whether to enable or disable SFX when gliding with Wings 4.");
			Wings4AttachSFXToPlayer = IBelieveICanFlyPlugin.context.config("05.07 - Wings 4", "02 - Attach SFX To Player", value: false, "Whether to enable or disable SFX for Wings 4 will be attached to the player and follow their movement.");
			Wings4StartSFX = IBelieveICanFlyPlugin.context.config("05.07 - Wings 4", "03 - Start SFX", "sfx_flap_glider_Ygg", "Sound effect to play when starting to glide with Wings 4. Use vanilla sound effect names.");
			Wings4LoopSFX = IBelieveICanFlyPlugin.context.config("05.07 - Wings 4", "04 - Loop SFX", "", "Sound effect to play continuously while gliding with Wings 4. Use vanilla sound effect names.");
			Wings4StopSFX = IBelieveICanFlyPlugin.context.config("05.07 - Wings 4", "05 - Stop SFX", "sfx_flap_glider_Ygg", "Sound effect to play when stopping gliding with Wings 4. Use vanilla sound effect names.");
			Wings4VFX = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "01 - VFX", value: false, "Whether to enable or disable VFX when gliding with Wings 4.");
			Wings4AttachEffectsToPlayer = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "02 - Attach VFX To Player", value: false, "Whether to enable or disable VFX for Wings 4 will be attached to the player and follow their movement.");
			Wings4StartVFX = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "03 - Start VFX", "", "Visual effect to play when starting to glide with Wings 4. Use vanilla VFX names.");
			Wings4LoopVFX = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "04 - Loop VFX", "", "Visual effect to play continuously while gliding with Wings 4. Use vanilla VFX names.");
			Wings4StopVFX = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "05 - Stop VFX", "", "Visual effect to play when stopping gliding with Wings 4. Use vanilla VFX names.");
			Wings4VFXPosition = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "06 - VFX Position", "Root", "Position for VFX for Wings 4: 'Root' (at player's feet), 'Middle' (at player's center), or 'Custom' (use custom coordinates).");
			Wings4VFXScale = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "07 - VFX Scale", 1f, "Scale factor for VFX for Wings 4. 1.0 is normal size.");
			Wings4VFXCustomX = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "08 - Custom X Offset", 0f, "X offset for custom VFX position for Wings 4 (only used when VFX Position is set to 'Custom').");
			Wings4VFXCustomY = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "09 - Custom Y Offset", 1f, "Y offset for custom VFX position for Wings 4 (only used when VFX Position is set to 'Custom').");
			Wings4VFXCustomZ = IBelieveICanFlyPlugin.context.config("05.08 - Wings 4", "10 - Custom Z Offset", 0f, "Z offset for custom VFX position for Wings 4 (only used when VFX Position is set to 'Custom').");
		}

		private static void RegisterWings5()
		{
			Wings5Enabled = IBelieveICanFlyPlugin.context.config("06.01 - Wings 5", "01 - Enabled", value: true, "Whether to enable or disable Wings 5. When enabled, this wings configuration will be active.");
			Wings5ItemName = IBelieveICanFlyPlugin.context.config("06.01 - Wings 5", "02 - Item Name", "Glider_Gjall_Fader_BackPack_Ygg", "Item prefab name that triggers Wings 5. Use vanilla item names like 'SwordFlametal' or custom item names.");
			Wings5VisualPrefab = IBelieveICanFlyPlugin.context.config("06.01 - Wings 5", "03 - Visual Prefab Override", "DragonWings_Ygg4", "Optional: Override the visual prefab shown when gliding. If empty, uses the trigger item's model. Use this to show wings while having a ring/amulet as the trigger item.");
			Wings5CheckRightHand = IBelieveICanFlyPlugin.context.config("06.02 - Wings 5", "01 - Check Right Hand", value: false, "Whether to enable or disable checking the right hand slot for Wings 5 item.");
			Wings5CheckLeftHand = IBelieveICanFlyPlugin.context.config("06.02 - Wings 5", "02 - Check Left Hand", value: false, "Whether to enable or disable checking the left hand slot for Wings 5 item.");
			Wings5CheckUtility = IBelieveICanFlyPlugin.context.config("06.02 - Wings 5", "03 - Check Utility Slot", value: true, "Whether to enable or disable checking the utility/belt slot for Wings 5 item.");
			Wings5UseFallReset = IBelieveICanFlyPlugin.context.config("06.02 - Wings 5", "04 - Prevent Fall Damage", value: true, "Whether to enable or disable fall damage when landing after gliding with Wings 5.");
			Wings5Animation = IBelieveICanFlyPlugin.context.config("06.02 - Wings 5", "05 - Use Animation", value: true, "Whether to enable or disable using animation while gliding with Wings 5.");
			Wings5MinActivationFallSpeed = IBelieveICanFlyPlugin.context.config("06.03 - Wings 5", "01 - Min Activation Fall Speed", -0.5f, "Prevent glide trigger if you barely left ground for Wings 5.");
			Wings5ForwardSpeed = IBelieveICanFlyPlugin.context.config("06.03 - Wings 5", "02 - Max Forward Speed", 20f, "Maximum forward speed while gliding with Wings 5.");
			Wings5ForwardForce = IBelieveICanFlyPlugin.context.config("06.03 - Wings 5", "03 - Forward Force", 14f, "Forward acceleration while gliding with Wings 5.");
			Wings5DescentSpeed = IBelieveICanFlyPlugin.context.config("06.03 - Wings 5", "04 - Max Descent Speed", -1f, "How fast you can fall while gliding with Wings 5 (more negative = faster fall).");
			Wings5AirTurnSpeed = IBelieveICanFlyPlugin.context.config("06.03 - Wings 5", "05 - Air Turn Speed", 150f, "Yaw control while gliding with Wings 5 (deg/sec).");
			Wings5LateralDamp = IBelieveICanFlyPlugin.context.config("06.03 - Wings 5", "06 - Lateral Damping", 0.15f, "Slight damping to stabilize lateral drift for Wings 5.");
			Wings5GroundProbeDistance = IBelieveICanFlyPlugin.context.config("06.03 - Wings 5", "07 - Ground Probe Distance", 2.5f, "Start cushioning this far from ground for Wings 5.");
			Wings5CushionDescentSpeed = IBelieveICanFlyPlugin.context.config("06.03 - Wings 5", "08 - Cushion Descent Speed", -0.7f, "Final descent cap near ground for Wings 5.");
			Wings5CushionLerp = IBelieveICanFlyPlugin.context.config("06.03 - Wings 5", "09 - Cushion Lerp", 0.6f, "How quickly we clamp toward the cushion speed for Wings 5.");
			Wings5TiltMaxPitch = IBelieveICanFlyPlugin.context.config("06.04 - Wings 5", "01 - Max Pitch", 25f, "Maximum pitch angle (nose up/down) in degrees for Wings 5.");
			Wings5TiltMaxRoll = IBelieveICanFlyPlugin.context.config("06.04 - Wings 5", "02 - Max Roll", 35f, "Maximum roll angle (banking) in degrees for Wings 5.");
			Wings5TiltPitchSmoothTime = IBelieveICanFlyPlugin.context.config("06.04 - Wings 5", "03 - Pitch Smooth Time", 0.15f, "How quickly pitch changes (lower = faster response) for Wings 5.");
			Wings5TiltRollSmoothTime = IBelieveICanFlyPlugin.context.config("06.04 - Wings 5", "04 - Roll Smooth Time", 0.1f, "How quickly roll/banking changes (lower = faster response) for Wings 5.");
			Wings5UpDownOffset = IBelieveICanFlyPlugin.context.config("06.05 - Wings 5", "01 - Up/Down Offset", -1f, "Adjust Wings 5 vertical position on the player's back. Higher values move it up.");
			Wings5LeftRightOffset = IBelieveICanFlyPlugin.context.config("06.05 - Wings 5", "02 - Left/Right Offset", 0f, "Adjust Wings 5 horizontal position on the player's back. Positive values move it to the right.");
			Wings5ForwardBackOffset = IBelieveICanFlyPlugin.context.config("06.05 - Wings 5", "03 - Forward/Back Offset", -2.5f, "Adjust Wings 5 position front-to-back on the player. Negative values move it backward.");
			Wings5RotationX = IBelieveICanFlyPlugin.context.config("06.06 - Wings 5", "01 - X Rotation", 70f, "Adjust Wings 5 pitch rotation in degrees. Controls tilt forward/backward.");
			Wings5RotationY = IBelieveICanFlyPlugin.context.config("06.06 - Wings 5", "02 - Y Rotation", 0f, "Adjust Wings 5 yaw rotation in degrees. Controls left/right facing.");
			Wings5RotationZ = IBelieveICanFlyPlugin.context.config("06.06 - Wings 5", "03 - Z Rotation", 0f, "Adjust Wings 5 roll rotation in degrees. Controls tilt to sides.");
			Wings5Scale = IBelieveICanFlyPlugin.context.config("06.06 - Wings 5", "04 - Scale", 0.2f, "Adjust the overall size of Wings 5. 1.0 is normal size.");
			Wings5SFX = IBelieveICanFlyPlugin.context.config("06.07 - Wings 5", "01 - SFX", value: true, "Whether to enable or disable SFX when gliding with Wings 5.");
			Wings5AttachSFXToPlayer = IBelieveICanFlyPlugin.context.config("06.07 - Wings 5", "02 - Attach SFX To Player", value: false, "Whether to enable or disable SFX for Wings 5 will be attached to the player and follow their movement.");
			Wings5StartSFX = IBelieveICanFlyPlugin.context.config("06.07 - Wings 5", "03 - Start SFX", "sfx_FireAddFuel", "Sound effect to play when starting to glide with Wings 5. Use vanilla sound effect names.");
			Wings5LoopSFX = IBelieveICanFlyPlugin.context.config("06.07 - Wings 5", "04 - Loop SFX", "", "Sound effect to play continuously while gliding with Wings 5. Use vanilla sound effect names.");
			Wings5StopSFX = IBelieveICanFlyPlugin.context.config("06.07 - Wings 5", "05 - Stop SFX", "sfx_flap_glider_Ygg", "Sound effect to play when stopping gliding with Wings 5. Use vanilla sound effect names.");
			Wings5VFX = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "01 - VFX", value: false, "Whether to enable or disable VFX when gliding with Wings 5.");
			Wings5AttachEffectsToPlayer = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "02 - Attach VFX To Player", value: false, "Whether to enable or disable VFX for Wings 5 will be attached to the player and follow their movement.");
			Wings5StartVFX = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "03 - Start VFX", "vfx_GjallFuelBurst_Ygg", "Visual effect to play when starting to glide with Wings 5. Use vanilla VFX names.");
			Wings5LoopVFX = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "04 - Loop VFX", "vfx_GjallFuelBurst_Ygg2", "Visual effect to play continuously while gliding with Wings 5. Use vanilla VFX names.");
			Wings5StopVFX = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "05 - Stop VFX", "vfx_odin_despawn", "Visual effect to play when stopping gliding with Wings 5. Use vanilla VFX names.");
			Wings5VFXPosition = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "06 - VFX Position", "Root", "Position for VFX for Wings 5: 'Root' (at player's feet), 'Middle' (at player's center), or 'Custom' (use custom coordinates).");
			Wings5VFXScale = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "07 - VFX Scale", 1f, "Scale factor for VFX for Wings 5. 1.0 is normal size.");
			Wings5VFXCustomX = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "08 - Custom X Offset", 0f, "X offset for custom VFX position for Wings 5 (only used when VFX Position is set to 'Custom').");
			Wings5VFXCustomY = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "09 - Custom Y Offset", 1f, "Y offset for custom VFX position for Wings 5 (only used when VFX Position is set to 'Custom').");
			Wings5VFXCustomZ = IBelieveICanFlyPlugin.context.config("06.08 - Wings 5", "10 - Custom Z Offset", 0f, "Z offset for custom VFX position for Wings 5 (only used when VFX Position is set to 'Custom').");
		}

		private static void RegisterWings6()
		{
			Wings6Enabled = IBelieveICanFlyPlugin.context.config("07.01 - Wings 6", "01 - Enabled", value: true, "Whether to enable or disable Wings 6. When enabled, this wings configuration will be active.");
			Wings6ItemName = IBelieveICanFlyPlugin.context.config("07.01 - Wings 6", "02 - Item Name", "Glider_Pelt_Ygg", "Item prefab name that triggers Wings 6. Use vanilla item names or custom item names.");
			Wings6VisualPrefab = IBelieveICanFlyPlugin.context.config("07.01 - Wings 6", "03 - Visual Prefab Override", "DragonWings_Ygg5", "Optional: Override the visual prefab shown when gliding. If empty, uses the trigger item's model. Use this to show wings while having a ring/amulet as the trigger item.");
			Wings6CheckRightHand = IBelieveICanFlyPlugin.context.config("07.02 - Wings 6", "01 - Check Right Hand", value: false, "Whether to enable or disable checking the right hand slot for Wings 6 item.");
			Wings6CheckLeftHand = IBelieveICanFlyPlugin.context.config("07.02 - Wings 6", "02 - Check Left Hand", value: false, "Whether to enable or disable checking the left hand slot for Wings 6 item.");
			Wings6CheckUtility = IBelieveICanFlyPlugin.context.config("07.02 - Wings 6", "03 - Check Utility Slot", value: true, "Whether to enable or disable checking the utility/belt slot for Wings 6 item.");
			Wings6UseFallReset = IBelieveICanFlyPlugin.context.config("07.02 - Wings 6", "04 - Prevent Fall Damage", value: true, "Whether to enable or disable fall damage when landing after gliding with Wings 6.");
			Wings6Animation = IBelieveICanFlyPlugin.context.config("07.02 - Wings 6", "05 - Use Animation", value: true, "Whether to enable or disable using animation while gliding with Wings 6.");
			Wings6MinActivationFallSpeed = IBelieveICanFlyPlugin.context.config("07.03 - Wings 6", "01 - Min Activation Fall Speed", -0.5f, "Prevent glide trigger if you barely left ground for Wings 6.");
			Wings6ForwardSpeed = IBelieveICanFlyPlugin.context.config("07.03 - Wings 6", "02 - Max Forward Speed", 10f, "Maximum forward speed while gliding with Wings 6.");
			Wings6ForwardForce = IBelieveICanFlyPlugin.context.config("07.03 - Wings 6", "03 - Forward Force", 5f, "Forward acceleration while gliding with Wings 6.");
			Wings6DescentSpeed = IBelieveICanFlyPlugin.context.config("07.03 - Wings 6", "04 - Max Descent Speed", -4f, "How fast you can fall while gliding with Wings 6 (more negative = faster fall).");
			Wings6AirTurnSpeed = IBelieveICanFlyPlugin.context.config("07.03 - Wings 6", "05 - Air Turn Speed", 120f, "Yaw control while gliding with Wings 6 (deg/sec).");
			Wings6LateralDamp = IBelieveICanFlyPlugin.context.config("07.03 - Wings 6", "06 - Lateral Damping", 0.15f, "Slight damping to stabilize lateral drift for Wings 6.");
			Wings6GroundProbeDistance = IBelieveICanFlyPlugin.context.config("07.03 - Wings 6", "07 - Ground Probe Distance", 2.5f, "Start cushioning this far from ground for Wings 6.");
			Wings6CushionDescentSpeed = IBelieveICanFlyPlugin.context.config("07.03 - Wings 6", "08 - Cushion Descent Speed", -0.7f, "Final descent cap near ground for Wings 6.");
			Wings6CushionLerp = IBelieveICanFlyPlugin.context.config("07.03 - Wings 6", "09 - Cushion Lerp", 0.6f, "How quickly we clamp toward the cushion speed for Wings 6.");
			Wings6TiltMaxPitch = IBelieveICanFlyPlugin.context.config("07.04 - Wings 6", "01 - Max Pitch", 25f, "Maximum pitch angle (nose up/down) in degrees for Wings 6.");
			Wings6TiltMaxRoll = IBelieveICanFlyPlugin.context.config("07.04 - Wings 6", "02 - Max Roll", 35f, "Maximum roll angle (banking) in degrees for Wings 6.");
			Wings6TiltPitchSmoothTime = IBelieveICanFlyPlugin.context.config("07.04 - Wings 6", "03 - Pitch Smooth Time", 0.15f, "How quickly pitch changes (lower = faster response) for Wings 6.");
			Wings6TiltRollSmoothTime = IBelieveICanFlyPlugin.context.config("07.04 - Wings 6", "04 - Roll Smooth Time", 0.1f, "How quickly roll/banking changes (lower = faster response) for Wings 6.");
			Wings6UpDownOffset = IBelieveICanFlyPlugin.context.config("07.05 - Wings 6", "01 - Up/Down Offset", 0.3f, "Adjust Wings 6 vertical position on the player's back. Higher values move it up.");
			Wings6LeftRightOffset = IBelieveICanFlyPlugin.context.config("07.05 - Wings 6", "02 - Left/Right Offset", 0f, "Adjust Wings 6 horizontal position on the player's back. Positive values move it to the right.");
			Wings6ForwardBackOffset = IBelieveICanFlyPlugin.context.config("07.05 - Wings 6", "03 - Forward/Back Offset", 0.7f, "Adjust Wings 6 position front-to-back on the player. Negative values move it backward.");
			Wings6RotationX = IBelieveICanFlyPlugin.context.config("07.06 - Wings 6", "01 - X Rotation", 10f, "Adjust Wings 6 pitch rotation in degrees. Controls tilt forward/backward.");
			Wings6RotationY = IBelieveICanFlyPlugin.context.config("07.06 - Wings 6", "02 - Y Rotation", 160f, "Adjust Wings 6 yaw rotation in degrees. Controls left/right facing.");
			Wings6RotationZ = IBelieveICanFlyPlugin.context.config("07.06 - Wings 6", "03 - Z Rotation", 0f, "Adjust Wings 6 roll rotation in degrees. Controls tilt to sides.");
			Wings6Scale = IBelieveICanFlyPlugin.context.config("07.06 - Wings 6", "04 - Scale", 0.3f, "Adjust the overall size of Wings 6. 1.0 is normal size.");
			Wings6SFX = IBelieveICanFlyPlugin.context.config("07.07 - Wings 6", "01 - SFX", value: true, "Whether to enable or disable SFX when gliding with Wings 6.");
			Wings6AttachSFXToPlayer = IBelieveICanFlyPlugin.context.config("07.07 - Wings 6", "02 - Attach SFX To Player", value: false, "Whether to enable or disable SFX for Wings 6 will be attached to the player and follow their movement.");
			Wings6StartSFX = IBelieveICanFlyPlugin.context.config("07.07 - Wings 6", "03 - Start SFX", "sfx_flap_glider_Ygg", "Sound effect to play when starting to glide with Wings 6. Use vanilla sound effect names.");
			Wings6LoopSFX = IBelieveICanFlyPlugin.context.config("07.07 - Wings 6", "04 - Loop SFX", "", "Sound effect to play continuously while gliding with Wings 6. Use vanilla sound effect names.");
			Wings6StopSFX = IBelieveICanFlyPlugin.context.config("07.07 - Wings 6", "05 - Stop SFX", "sfx_flap_glider_Ygg", "Sound effect to play when stopping gliding with Wings 6. Use vanilla sound effect names.");
			Wings6VFX = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "01 - VFX", value: false, "Whether to enable or disable VFX when gliding with Wings 6.");
			Wings6AttachEffectsToPlayer = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "02 - Attach VFX To Player", value: false, "Whether to enable or disable VFX for Wings 6 will be attached to the player and follow their movement.");
			Wings6StartVFX = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "03 - Start VFX", "", "Visual effect to play when starting to glide with Wings 6. Use vanilla VFX names.");
			Wings6LoopVFX = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "04 - Loop VFX", "", "Visual effect to play continuously while gliding with Wings 6. Use vanilla VFX names.");
			Wings6StopVFX = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "05 - Stop VFX", "", "Visual effect to play when stopping gliding with Wings 6. Use vanilla VFX names.");
			Wings6VFXPosition = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "06 - VFX Position", "Root", "Position for VFX for Wings 6: 'Root' (at player's feet), 'Middle' (at player's center), or 'Custom' (use custom coordinates).");
			Wings6VFXScale = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "07 - VFX Scale", 1f, "Scale factor for VFX for Wings 6. 1.0 is normal size.");
			Wings6VFXCustomX = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "08 - Custom X Offset", 0f, "X offset for custom VFX position for Wings 6 (only used when VFX Position is set to 'Custom').");
			Wings6VFXCustomY = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "09 - Custom Y Offset", 1f, "Y offset for custom VFX position for Wings 6 (only used when VFX Position is set to 'Custom').");
			Wings6VFXCustomZ = IBelieveICanFlyPlugin.context.config("07.08 - Wings 6", "10 - Custom Z Offset", 0f, "Z offset for custom VFX position for Wings 6 (only used when VFX Position is set to 'Custom').");
		}

		public static (bool enabled, int wingsIndex) GetWingsConfigForItem(ItemData item)
		{
			if (item == null)
			{
				return (false, -1);
			}
			string text = (Object.op_Implicit((Object)(object)item.m_dropPrefab) ? ((Object)item.m_dropPrefab).name : "");
			string name = item.m_shared.m_name;
			if (Wings1Enabled.Value && !string.IsNullOrEmpty(Wings1ItemName.Value) && (text.Equals(Wings1ItemName.Value) || name.Equals(Wings1ItemName.Value) || name.Contains(Wings1ItemName.Value)))
			{
				return (true, 1);
			}
			if (Wings2Enabled.Value && !string.IsNullOrEmpty(Wings2ItemName.Value) && (text.Equals(Wings2ItemName.Value) || name.Equals(Wings2ItemName.Value) || name.Contains(Wings2ItemName.Value)))
			{
				return (true, 2);
			}
			if (Wings3Enabled.Value && !string.IsNullOrEmpty(Wings3ItemName.Value) && (text.Equals(Wings3ItemName.Value) || name.Equals(Wings3ItemName.Value) || name.Contains(Wings3ItemName.Value)))
			{
				return (true, 3);
			}
			if (Wings4Enabled.Value && !string.IsNullOrEmpty(Wings4ItemName.Value) && (text.Equals(Wings4ItemName.Value) || name.Equals(Wings4ItemName.Value) || name.Contains(Wings4ItemName.Value)))
			{
				return (true, 4);
			}
			if (Wings5Enabled.Value && !string.IsNullOrEmpty(Wings5ItemName.Value) && (text.Equals(Wings5ItemName.Value) || name.Equals(Wings5ItemName.Value) || name.Contains(Wings5ItemName.Value)))
			{
				return (true, 5);
			}
			if (Wings6Enabled.Value && !string.IsNullOrEmpty(Wings6ItemName.Value) && (text.Equals(Wings6ItemName.Value) || name.Equals(Wings6ItemName.Value) || name.Contains(Wings6ItemName.Value)))
			{
				return (true, 6);
			}
			return (false, -1);
		}

		public static string GetWingsVisualPrefab(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			string result = wingsIndex switch
			{
				1 => Wings1VisualPrefab.Value, 
				2 => Wings2VisualPrefab.Value, 
				3 => Wings3VisualPrefab.Value, 
				4 => Wings4VisualPrefab.Value, 
				5 => Wings5VisualPrefab.Value, 
				6 => Wings6VisualPrefab.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool GetWingsCheckRightHand(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			bool result = wingsIndex switch
			{
				1 => Wings1CheckRightHand.Value, 
				2 => Wings2CheckRightHand.Value, 
				3 => Wings3CheckRightHand.Value, 
				4 => Wings4CheckRightHand.Value, 
				5 => Wings5CheckRightHand.Value, 
				6 => Wings6CheckRightHand.Value, 
				_ => true, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool GetWingsCheckLeftHand(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			bool result = wingsIndex switch
			{
				1 => Wings1CheckLeftHand.Value, 
				2 => Wings2CheckLeftHand.Value, 
				3 => Wings3CheckLeftHand.Value, 
				4 => Wings4CheckLeftHand.Value, 
				5 => Wings5CheckLeftHand.Value, 
				6 => Wings6CheckLeftHand.Value, 
				_ => false, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool GetWingsCheckUtility(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			bool result = wingsIndex switch
			{
				1 => Wings1CheckUtility.Value, 
				2 => Wings2CheckUtility.Value, 
				3 => Wings3CheckUtility.Value, 
				4 => Wings4CheckUtility.Value, 
				5 => Wings5CheckUtility.Value, 
				6 => Wings6CheckUtility.Value, 
				_ => false, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool GetWingsUseFallReset(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			bool result = wingsIndex switch
			{
				1 => Wings1UseFallReset.Value, 
				2 => Wings2UseFallReset.Value, 
				3 => Wings3UseFallReset.Value, 
				4 => Wings4UseFallReset.Value, 
				5 => Wings5UseFallReset.Value, 
				6 => Wings6UseFallReset.Value, 
				_ => true, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool GetWingsAnimation(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			bool result = wingsIndex switch
			{
				1 => Wings1Animation.Value, 
				2 => Wings2Animation.Value, 
				3 => Wings3Animation.Value, 
				4 => Wings4Animation.Value, 
				5 => Wings5Animation.Value, 
				6 => Wings6Animation.Value, 
				_ => true, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsMinActivationFallSpeed(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1MinActivationFallSpeed.Value, 
				2 => Wings2MinActivationFallSpeed.Value, 
				3 => Wings3MinActivationFallSpeed.Value, 
				4 => Wings4MinActivationFallSpeed.Value, 
				5 => Wings5MinActivationFallSpeed.Value, 
				6 => Wings6MinActivationFallSpeed.Value, 
				_ => -0.5f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool GetWingsSFX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			bool result = wingsIndex switch
			{
				1 => Wings1SFX.Value, 
				2 => Wings2SFX.Value, 
				3 => Wings3SFX.Value, 
				4 => Wings4SFX.Value, 
				5 => Wings5SFX.Value, 
				6 => Wings6SFX.Value, 
				_ => true, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetWingsStartSFX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			string result = wingsIndex switch
			{
				1 => Wings1StartSFX.Value, 
				2 => Wings2StartSFX.Value, 
				3 => Wings3StartSFX.Value, 
				4 => Wings4StartSFX.Value, 
				5 => Wings5StartSFX.Value, 
				6 => Wings6StartSFX.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetWingsLoopSFX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			string result = wingsIndex switch
			{
				1 => Wings1LoopSFX.Value, 
				2 => Wings2LoopSFX.Value, 
				3 => Wings3LoopSFX.Value, 
				4 => Wings4LoopSFX.Value, 
				5 => Wings5LoopSFX.Value, 
				6 => Wings6LoopSFX.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetWingsStopSFX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			string result = wingsIndex switch
			{
				1 => Wings1StopSFX.Value, 
				2 => Wings2StopSFX.Value, 
				3 => Wings3StopSFX.Value, 
				4 => Wings4StopSFX.Value, 
				5 => Wings5StopSFX.Value, 
				6 => Wings6StopSFX.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool GetWingsVFX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			bool result = wingsIndex switch
			{
				1 => Wings1VFX.Value, 
				2 => Wings2VFX.Value, 
				3 => Wings3VFX.Value, 
				4 => Wings4VFX.Value, 
				5 => Wings5VFX.Value, 
				6 => Wings6VFX.Value, 
				_ => true, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetWingsStartVFX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			string result = wingsIndex switch
			{
				1 => Wings1StartVFX.Value, 
				2 => Wings2StartVFX.Value, 
				3 => Wings3StartVFX.Value, 
				4 => Wings4StartVFX.Value, 
				5 => Wings5StartVFX.Value, 
				6 => Wings6StartVFX.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetWingsLoopVFX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			string result = wingsIndex switch
			{
				1 => Wings1LoopVFX.Value, 
				2 => Wings2LoopVFX.Value, 
				3 => Wings3LoopVFX.Value, 
				4 => Wings4LoopVFX.Value, 
				5 => Wings5LoopVFX.Value, 
				6 => Wings6LoopVFX.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetWingsStopVFX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			string result = wingsIndex switch
			{
				1 => Wings1StopVFX.Value, 
				2 => Wings2StopVFX.Value, 
				3 => Wings3StopVFX.Value, 
				4 => Wings4StopVFX.Value, 
				5 => Wings5StopVFX.Value, 
				6 => Wings6StopVFX.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsForwardSpeed(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1ForwardSpeed.Value, 
				2 => Wings2ForwardSpeed.Value, 
				3 => Wings3ForwardSpeed.Value, 
				4 => Wings4ForwardSpeed.Value, 
				5 => Wings5ForwardSpeed.Value, 
				6 => Wings6ForwardSpeed.Value, 
				_ => 14f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsForwardForce(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1ForwardForce.Value, 
				2 => Wings2ForwardForce.Value, 
				3 => Wings3ForwardForce.Value, 
				4 => Wings4ForwardForce.Value, 
				5 => Wings5ForwardForce.Value, 
				6 => Wings6ForwardForce.Value, 
				_ => 10f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsDescentSpeed(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1DescentSpeed.Value, 
				2 => Wings2DescentSpeed.Value, 
				3 => Wings3DescentSpeed.Value, 
				4 => Wings4DescentSpeed.Value, 
				5 => Wings5DescentSpeed.Value, 
				6 => Wings6DescentSpeed.Value, 
				_ => -4f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsAirTurnSpeed(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1AirTurnSpeed.Value, 
				2 => Wings2AirTurnSpeed.Value, 
				3 => Wings3AirTurnSpeed.Value, 
				4 => Wings4AirTurnSpeed.Value, 
				5 => Wings5AirTurnSpeed.Value, 
				6 => Wings6AirTurnSpeed.Value, 
				_ => 120f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsLateralDamp(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1LateralDamp.Value, 
				2 => Wings2LateralDamp.Value, 
				3 => Wings3LateralDamp.Value, 
				4 => Wings4LateralDamp.Value, 
				5 => Wings5LateralDamp.Value, 
				6 => Wings6LateralDamp.Value, 
				_ => 0.15f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsGroundProbeDistance(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1GroundProbeDistance.Value, 
				2 => Wings2GroundProbeDistance.Value, 
				3 => Wings3GroundProbeDistance.Value, 
				4 => Wings4GroundProbeDistance.Value, 
				5 => Wings5GroundProbeDistance.Value, 
				6 => Wings6GroundProbeDistance.Value, 
				_ => 2.5f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsCushionDescentSpeed(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1CushionDescentSpeed.Value, 
				2 => Wings2CushionDescentSpeed.Value, 
				3 => Wings3CushionDescentSpeed.Value, 
				4 => Wings4CushionDescentSpeed.Value, 
				5 => Wings5CushionDescentSpeed.Value, 
				6 => Wings6CushionDescentSpeed.Value, 
				_ => -0.7f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsCushionLerp(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1CushionLerp.Value, 
				2 => Wings2CushionLerp.Value, 
				3 => Wings3CushionLerp.Value, 
				4 => Wings4CushionLerp.Value, 
				5 => Wings5CushionLerp.Value, 
				6 => Wings6CushionLerp.Value, 
				_ => 0.6f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsTiltMaxPitch(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1TiltMaxPitch.Value, 
				2 => Wings2TiltMaxPitch.Value, 
				3 => Wings3TiltMaxPitch.Value, 
				4 => Wings4TiltMaxPitch.Value, 
				5 => Wings5TiltMaxPitch.Value, 
				6 => Wings6TiltMaxPitch.Value, 
				_ => 25f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsTiltMaxRoll(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1TiltMaxRoll.Value, 
				2 => Wings2TiltMaxRoll.Value, 
				3 => Wings3TiltMaxRoll.Value, 
				4 => Wings4TiltMaxRoll.Value, 
				5 => Wings5TiltMaxRoll.Value, 
				6 => Wings6TiltMaxRoll.Value, 
				_ => 35f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsTiltPitchSmoothTime(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1TiltPitchSmoothTime.Value, 
				2 => Wings2TiltPitchSmoothTime.Value, 
				3 => Wings3TiltPitchSmoothTime.Value, 
				4 => Wings4TiltPitchSmoothTime.Value, 
				5 => Wings5TiltPitchSmoothTime.Value, 
				6 => Wings6TiltPitchSmoothTime.Value, 
				_ => 0.15f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsTiltRollSmoothTime(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1TiltRollSmoothTime.Value, 
				2 => Wings2TiltRollSmoothTime.Value, 
				3 => Wings3TiltRollSmoothTime.Value, 
				4 => Wings4TiltRollSmoothTime.Value, 
				5 => Wings5TiltRollSmoothTime.Value, 
				6 => Wings6TiltRollSmoothTime.Value, 
				_ => 0.1f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsUpDownOffset(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1UpDownOffset.Value, 
				2 => Wings2UpDownOffset.Value, 
				3 => Wings3UpDownOffset.Value, 
				4 => Wings4UpDownOffset.Value, 
				5 => Wings5UpDownOffset.Value, 
				6 => Wings6UpDownOffset.Value, 
				_ => 1.2f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsLeftRightOffset(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1LeftRightOffset.Value, 
				2 => Wings2LeftRightOffset.Value, 
				3 => Wings3LeftRightOffset.Value, 
				4 => Wings4LeftRightOffset.Value, 
				5 => Wings5LeftRightOffset.Value, 
				6 => Wings6LeftRightOffset.Value, 
				_ => 0f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsForwardBackOffset(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1ForwardBackOffset.Value, 
				2 => Wings2ForwardBackOffset.Value, 
				3 => Wings3ForwardBackOffset.Value, 
				4 => Wings4ForwardBackOffset.Value, 
				5 => Wings5ForwardBackOffset.Value, 
				6 => Wings6ForwardBackOffset.Value, 
				_ => -0.1f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsRotationX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1RotationX.Value, 
				2 => Wings2RotationX.Value, 
				3 => Wings3RotationX.Value, 
				4 => Wings4RotationX.Value, 
				5 => Wings5RotationX.Value, 
				6 => Wings6RotationX.Value, 
				_ => 0f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsRotationY(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1RotationY.Value, 
				2 => Wings2RotationY.Value, 
				3 => Wings3RotationY.Value, 
				4 => Wings4RotationY.Value, 
				5 => Wings5RotationY.Value, 
				6 => Wings6RotationY.Value, 
				_ => 180f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsRotationZ(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1RotationZ.Value, 
				2 => Wings2RotationZ.Value, 
				3 => Wings3RotationZ.Value, 
				4 => Wings4RotationZ.Value, 
				5 => Wings5RotationZ.Value, 
				6 => Wings6RotationZ.Value, 
				_ => 0f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsScale(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1Scale.Value, 
				2 => Wings2Scale.Value, 
				3 => Wings3Scale.Value, 
				4 => Wings4Scale.Value, 
				5 => Wings5Scale.Value, 
				6 => Wings6Scale.Value, 
				_ => 1f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool GetWingsAttachSFXToPlayer(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			bool result = wingsIndex switch
			{
				1 => Wings1AttachSFXToPlayer.Value, 
				2 => Wings2AttachSFXToPlayer.Value, 
				3 => Wings3AttachSFXToPlayer.Value, 
				4 => Wings4AttachSFXToPlayer.Value, 
				5 => Wings5AttachSFXToPlayer.Value, 
				6 => Wings6AttachSFXToPlayer.Value, 
				_ => true, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool GetWingsAttachEffectsToPlayer(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			bool result = wingsIndex switch
			{
				1 => Wings1AttachEffectsToPlayer.Value, 
				2 => Wings2AttachEffectsToPlayer.Value, 
				3 => Wings3AttachEffectsToPlayer.Value, 
				4 => Wings4AttachEffectsToPlayer.Value, 
				5 => Wings5AttachEffectsToPlayer.Value, 
				6 => Wings6AttachEffectsToPlayer.Value, 
				_ => true, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetWingsVFXPosition(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			string result = wingsIndex switch
			{
				1 => Wings1VFXPosition.Value, 
				2 => Wings2VFXPosition.Value, 
				3 => Wings3VFXPosition.Value, 
				4 => Wings4VFXPosition.Value, 
				5 => Wings5VFXPosition.Value, 
				6 => Wings6VFXPosition.Value, 
				_ => "Root", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsVFXScale(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1VFXScale.Value, 
				2 => Wings2VFXScale.Value, 
				3 => Wings3VFXScale.Value, 
				4 => Wings4VFXScale.Value, 
				5 => Wings5VFXScale.Value, 
				6 => Wings6VFXScale.Value, 
				_ => 1f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsVFXCustomX(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1VFXCustomX.Value, 
				2 => Wings2VFXCustomX.Value, 
				3 => Wings3VFXCustomX.Value, 
				4 => Wings4VFXCustomX.Value, 
				5 => Wings5VFXCustomX.Value, 
				6 => Wings6VFXCustomX.Value, 
				_ => 0f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsVFXCustomY(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1VFXCustomY.Value, 
				2 => Wings2VFXCustomY.Value, 
				3 => Wings3VFXCustomY.Value, 
				4 => Wings4VFXCustomY.Value, 
				5 => Wings5VFXCustomY.Value, 
				6 => Wings6VFXCustomY.Value, 
				_ => 1f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static float GetWingsVFXCustomZ(int wingsIndex)
		{
			if (1 == 0)
			{
			}
			float result = wingsIndex switch
			{
				1 => Wings1VFXCustomZ.Value, 
				2 => Wings2VFXCustomZ.Value, 
				3 => Wings3VFXCustomZ.Value, 
				4 => Wings4VFXCustomZ.Value, 
				5 => Wings5VFXCustomZ.Value, 
				6 => Wings6VFXCustomZ.Value, 
				_ => 0f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static int GetCurrentWingsIndex()
		{
			return GliderSystem.GetCurrentWingsIndex();
		}
	}
	public static class Item
	{
		public static ItemManager.Item? Glider_BackPack_Ygg { get; private set; }

		public static ItemManager.Item? Glider_Pelt_Ygg { get; private set; }

		public static ItemManager.Item? Glider_Gjall_BackPack_Ygg { get; private set; }

		public static ItemManager.Item? Glider_Gjall_Fader_BackPack_Ygg { get; private set; }

		public static ItemManager.Item? Glider_BackPack_DragonModer_Ygg { get; private set; }

		public static ItemManager.Item? Glider_BackPack_BlackDragon_Y