using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Joive.BurglinGnomes.SwimmingRing.Config;
using Joive.BurglinGnomes.SwimmingRing.Game;
using Joive.BurglinGnomes.SwimmingRing.Gameplay;
using Joive.BurglinGnomes.SwimmingRing.Items;
using Lightbug.CharacterControllerPro.Core;
using Lightbug.CharacterControllerPro.Implementation;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("Joive")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Adds a craftable swimming ring equipment item.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e93357b17a5bd3c061e91c11c78c776a117b3496")]
[assembly: AssemblyProduct("BG Swimming Ring")]
[assembly: AssemblyTitle("BG-SwimmingRing-Joive")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 Joive.BurglinGnomes.SwimmingRing
{
	[BepInPlugin("joive.bg.swimmingring", "BG Swimming Ring", "1.0.0")]
	public sealed class SwimmingRingPlugin : BaseUnityPlugin
	{
		public const string PluginId = "joive.bg.swimmingring";

		public const string PluginName = "BG Swimming Ring";

		public const string Version = "1.0.0";

		private Harmony harmony;

		private void Awake()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			PluginConfig.Bind(((BaseUnityPlugin)this).Config);
			ModLog.Bind(((BaseUnityPlugin)this).Logger);
			SwimmingRingDefinition.Configure(PluginConfig.PlasticCost.Value);
			GameText.RegisterSwimmingRingText();
			if (PluginConfig.DebugLogs.Value)
			{
				ModLog.Info("BG-SwimmingRing-Joive.dll loaded. Version: 1.0.0");
			}
			harmony = new Harmony("joive.bg.swimmingring");
			harmony.PatchAll(typeof(SwimmingRingPlugin).Assembly);
			ModLog.Info("BG Swimming Ring 1.0.0 loaded.");
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}
	}
}
namespace Joive.BurglinGnomes.SwimmingRing.Patches
{
	[HarmonyPatch(typeof(EquipmentHandler), "SetWearedEquipment")]
	internal static class EquipmentHandlerSetWearedEquipmentPatch
	{
		private static bool Prefix(string name)
		{
			return !GameApi.IsSwimmingRingName(name);
		}
	}
	[HarmonyPatch(typeof(EquipmentHandler), "SetOtherWearedEquipment")]
	internal static class EquipmentHandlerSetOtherWearedEquipmentPatch
	{
		private static bool Prefix(string name)
		{
			return !GameApi.IsSwimmingRingName(name);
		}
	}
	[HarmonyPatch(typeof(GnomiumDeposit), "OnNetworkSpawn")]
	internal static class GnomiumDepositOnNetworkSpawnPatch
	{
		private static void Postfix(GnomiumDeposit __instance)
		{
			CraftingRegistry.EnsureRegistered(__instance);
		}
	}
	[HarmonyPatch(typeof(InventoryBase), "OnNetworkSpawn")]
	internal static class InventoryOnNetworkSpawnPatch
	{
		private static void Postfix(InventoryBase __instance)
		{
			ItemRegistry.EnsureRegistered(__instance.BoundItems);
		}
	}
	[HarmonyPatch(typeof(ItemInstance), "OnNetworkSpawn")]
	internal static class ItemInstanceOnNetworkSpawnPatch
	{
		private static void Postfix(ItemInstance __instance)
		{
			SwimmingRingVisualApplier.Apply(__instance);
		}
	}
	[HarmonyPatch(typeof(ItemInstance), "OnInstanceDataChange")]
	internal static class ItemInstanceOnInstanceDataChangePatch
	{
		private static void Postfix(ItemInstance __instance)
		{
			SwimmingRingVisualApplier.Apply(__instance);
		}
	}
	[HarmonyPatch(typeof(NormalMovement), "HandleVelocity")]
	internal static class NormalMovementHandleVelocityPatch
	{
		private static void Postfix(NormalMovement __instance, float dt)
		{
			SwimmingRingMovement.Apply(__instance, dt);
		}
	}
	[HarmonyPatch(typeof(Unpinned), "CheckEnterTransition")]
	internal static class UnpinnedCheckEnterTransitionPatch
	{
		private static void Postfix(Unpinned __instance, object fromState, ref bool __result)
		{
			if (__result && fromState is NormalMovement && GameApi.TryGetPlayer((Component)(object)__instance, out var player) && GameApi.CanStandFromWater(player) && GameApi.IsPlayerInWater(__instance))
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(Unpinned), "CheckExitTransition")]
	internal static class UnpinnedCheckExitTransitionPatch
	{
		private static void Prefix(Unpinned __instance)
		{
			if (GameApi.TryGetPlayer((Component)(object)__instance, out var player) && GameApi.CanStandFromWater(player) && GameApi.IsPlayerInWater(__instance))
			{
				player.StateController.EnqueueTransition<NormalMovement>();
			}
		}
	}
}
namespace Joive.BurglinGnomes.SwimmingRing.Items
{
	internal static class SwimmingRingDefinition
	{
		internal const string ItemName = "Inflatable Swimming Ring";

		internal const string LegacyItemName = "inflatable_swimming_ring";

		internal const string DisplayName = "Inflatable Swimming Ring";

		internal const string Description = "Keeps you steady in water.";

		internal const float MaxDurability = 100f;

		internal static int PlasticCost { get; private set; } = 4;

		internal static void Configure(int plasticCost)
		{
			PlasticCost = plasticCost;
		}

		internal static LocalizedString NameText()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			return new LocalizedString(TableReference.op_Implicit("Items"), TableEntryReference.op_Implicit("Inflatable Swimming Ring"));
		}

		internal static LocalizedString DescriptionText()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			return new LocalizedString(TableReference.op_Implicit("Items Descriptions"), TableEntryReference.op_Implicit("Inflatable Swimming Ring"));
		}
	}
}
namespace Joive.BurglinGnomes.SwimmingRing.Game
{
	internal static class CraftingRegistry
	{
		private static bool missingPlasticLogged;

		internal static void EnsureRegistered(GnomiumDeposit deposit)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			if (GameApi.IsEnabled && !((Object)(object)deposit == (Object)null) && !((Object)(object)deposit.Recipes == (Object)null) && !((Object)(object)deposit.ResourceInventory == (Object)null))
			{
				ItemData val = ItemRegistry.EnsureRegistered(deposit.ResourceInventory.BoundItems);
				ItemData val2 = FindPlasticResource(deposit.ResourceInventory.BoundItems);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null) && !HasRecipe(deposit.Recipes, val))
				{
					Recipe val3 = new Recipe();
					val3.craftResultType = (CraftResultType)0;
					val3.cost = (ItemCost[])(object)new ItemCost[1]
					{
						new ItemCost
						{
							item = val2,
							amount = SwimmingRingDefinition.PlasticCost
						}
					};
					Recipe val4 = val3;
					GameApi.SetRecipeItem(val4, val);
					Array.Resize(ref deposit.Recipes.recipes, deposit.Recipes.recipes.Length + 1);
					deposit.Recipes.recipes[deposit.Recipes.recipes.Length - 1] = val4;
					GameApi.Debug("Registered recipe: Inflatable Swimming Ring");
				}
			}
		}

		private static ItemData FindPlasticResource(AllItems allItems)
		{
			string resourceName = ResourceStorage.GetResourceName(3);
			int num = default(int);
			ItemData item = allItems.GetItem(resourceName, ref num);
			if ((Object)(object)item == (Object)null && !missingPlasticLogged)
			{
				missingPlasticLogged = true;
				ModLog.Warning("Plastic resource item was not found.");
			}
			return item;
		}

		private static bool HasRecipe(CraftingRecipes recipes, ItemData result)
		{
			Recipe[] recipes2 = recipes.recipes;
			foreach (Recipe val in recipes2)
			{
				if (val != null && (Object)(object)val.CraftResult == (Object)(object)result)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class GameApi
	{
		private static readonly FieldInfo RecipeItemField = AccessTools.Field(typeof(Recipe), "item");

		private static readonly MethodInfo CheckIsPlayerInWaterMethod = AccessTools.Method(typeof(Unpinned), "CheckIsPlayerInWater", (Type[])null, (Type[])null);

		private static readonly MethodInfo LoadImageMethod = FindLoadImageMethod();

		internal static bool Ready { get; } = Validate();

		internal static bool IsEnabled
		{
			get
			{
				if (PluginConfig.EnableMod != null && PluginConfig.EnableMod.Value)
				{
					return Ready;
				}
				return false;
			}
		}

		internal static void SetRecipeItem(Recipe recipe, ItemData item)
		{
			RecipeItemField.SetValue(recipe, item);
		}

		internal static bool LoadImage(Texture2D texture, byte[] bytes)
		{
			if (LoadImageMethod == null)
			{
				return false;
			}
			object[] parameters = ((LoadImageMethod.GetParameters().Length != 2) ? new object[3] { texture, bytes, false } : new object[2] { texture, bytes });
			return (bool)LoadImageMethod.Invoke(null, parameters);
		}

		internal static bool IsPlayerInWater(Unpinned state)
		{
			return (bool)CheckIsPlayerInWaterMethod.Invoke(state, null);
		}

		internal static bool HasSwimmingRing(PlayerNetworking player)
		{
			return HasSwimmingRing(player, equippedOnly: false);
		}

		internal static bool HasEquippedSwimmingRing(PlayerNetworking player)
		{
			return HasSwimmingRing(player, equippedOnly: true);
		}

		private static bool HasSwimmingRing(PlayerNetworking player, bool equippedOnly)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)player.Inventory == (Object)null)
			{
				return false;
			}
			foreach (InventoryItem content in ((InventoryBase)player.Inventory).Contents)
			{
				InventoryItem current = content;
				if (((InventoryItem)(ref current)).IsValidItem && (!equippedOnly || current.slotIndex <= 1))
				{
					ItemData itemData = ((InventoryBase)player.Inventory).GetItemData((int)((InventoryItem)(ref current)).ItemIndex);
					if ((Object)(object)itemData != (Object)null && IsSwimmingRing(itemData))
					{
						return true;
					}
				}
			}
			return false;
		}

		internal static bool IsSwimmingRing(ItemData itemData)
		{
			if ((Object)(object)itemData != (Object)null)
			{
				return IsSwimmingRingName(((CraftableItemBase)itemData).Name);
			}
			return false;
		}

		internal static bool IsSwimmingRingName(string itemName)
		{
			if (!(itemName == "Inflatable Swimming Ring"))
			{
				return itemName == "inflatable_swimming_ring";
			}
			return true;
		}

		internal static bool CanStandFromWater(PlayerNetworking player)
		{
			if (HasEquippedSwimmingRing(player) && !((HealthBase)player.Health).Dead && !player.Tied && player.StatusEffects.StunnedDuration <= 0f)
			{
				return !player.Dismemberment.IsMissingLeg;
			}
			return false;
		}

		internal static bool TryGetPlayer(Component component, out PlayerNetworking player)
		{
			player = component.GetComponentInParent<PlayerNetworking>();
			return (Object)(object)player != (Object)null;
		}

		internal static void Debug(string message)
		{
			if (PluginConfig.DebugLogs != null && PluginConfig.DebugLogs.Value)
			{
				ModLog.Info(message);
			}
		}

		private static bool Validate()
		{
			return (byte)(1u & (Require(RecipeItemField, "CraftingRecipes.Recipe.item") ? 1u : 0u) & (Require(CheckIsPlayerInWaterMethod, "Unpinned.CheckIsPlayerInWater") ? 1u : 0u) & (Require(LoadImageMethod, "UnityEngine.ImageConversion.LoadImage") ? 1u : 0u)) != 0;
		}

		private static MethodInfo FindLoadImageMethod()
		{
			Type type = Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule");
			if (type == null)
			{
				return null;
			}
			return type.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
			{
				typeof(Texture2D),
				typeof(byte[])
			}, null) ?? type.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
			{
				typeof(Texture2D),
				typeof(byte[]),
				typeof(bool)
			}, null);
		}

		private static bool Require(MemberInfo member, string name)
		{
			if (member != null)
			{
				return true;
			}
			ModLog.Warning("Missing game member: " + name);
			return false;
		}
	}
	internal static class GameText
	{
		private readonly struct TextPair
		{
			internal readonly string Name;

			internal readonly string Description;

			internal TextPair(string name, string description)
			{
				Name = name;
				Description = description;
			}
		}

		private static readonly Dictionary<string, TextPair> TextByLanguage = new Dictionary<string, TextPair>
		{
			{
				"en",
				new TextPair("Inflatable Swimming Ring", "Keeps you steady in water.")
			},
			{
				"ru",
				new TextPair("Надувной круг", "Помогает держаться на воде.")
			},
			{
				"uk",
				new TextPair("Надувний круг", "Допомагає триматися на воді.")
			},
			{
				"de",
				new TextPair("Aufblasbarer Schwimmring", "Hilft dir, im Wasser stabil zu bleiben.")
			},
			{
				"fr",
				new TextPair("Bouée gonflable", "Vous aide à rester stable dans l'eau.")
			},
			{
				"es",
				new TextPair("Flotador inflable", "Te ayuda a mantenerte estable en el agua.")
			},
			{
				"pt",
				new TextPair("Boia inflável", "Ajuda você a se manter estável na água.")
			},
			{
				"it",
				new TextPair("Ciambella gonfiabile", "Ti aiuta a restare stabile in acqua.")
			},
			{
				"pl",
				new TextPair("Nadmuchiwane koło", "Pomaga utrzymać się stabilnie w wodzie.")
			},
			{
				"tr",
				new TextPair("Şişme yüzme simidi", "Suda dengede kalmana yardımcı olur.")
			},
			{
				"zh",
				new TextPair("充气游泳圈", "帮助你在水中保持稳定。")
			},
			{
				"ja",
				new TextPair("空気入り浮き輪", "水中で体勢を保ちやすくする。")
			},
			{
				"ko",
				new TextPair("공기 주입식 튜브", "물속에서 안정적으로 움직일 수 있게 해 줍니다.")
			}
		};

		internal static void RegisterSwimmingRingText()
		{
			IReadOnlyList<Locale> locales = LocalizationSettings.AvailableLocales.Locales;
			if (locales == null || locales.Count == 0)
			{
				AddText("Items", "Inflatable Swimming Ring", "Inflatable Swimming Ring");
				AddText("Items Descriptions", "Inflatable Swimming Ring", "Keeps you steady in water.");
				return;
			}
			foreach (Locale item in locales)
			{
				TextPair text = GetText(item);
				AddText("Items", "Inflatable Swimming Ring", text.Name, item);
				AddText("Items Descriptions", "Inflatable Swimming Ring", text.Description, item);
			}
		}

		private static void AddText(string tableName, string key, string value)
		{
			AddText(tableName, key, value, null);
		}

		private static void AddText(string tableName, string key, string value, Locale locale)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			StringTable table = ((LocalizedDatabase<StringTable, StringTableEntry>)(object)LocalizationSettings.StringDatabase).GetTable(TableReference.op_Implicit(tableName), (Locale)null);
			if ((Object)(object)locale != (Object)null)
			{
				table = ((LocalizedDatabase<StringTable, StringTableEntry>)(object)LocalizationSettings.StringDatabase).GetTable(TableReference.op_Implicit(tableName), locale);
			}
			if (!((Object)(object)table == (Object)null) && ((DetailedLocalizationTable<StringTableEntry>)(object)table).GetEntry(key) == null)
			{
				((DetailedLocalizationTable<StringTableEntry>)(object)table).AddEntry(key, value);
			}
		}

		private static TextPair GetText(Locale locale)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			LocaleIdentifier identifier = locale.Identifier;
			string text = ((LocaleIdentifier)(ref identifier)).Code.ToLowerInvariant();
			if (TextByLanguage.TryGetValue(text, out var value))
			{
				return value;
			}
			int num = text.IndexOf('-');
			string key = ((num >= 0) ? text.Substring(0, num) : text);
			if (TextByLanguage.TryGetValue(key, out var value2))
			{
				return value2;
			}
			return TextByLanguage["en"];
		}
	}
	internal static class ItemRegistry
	{
		private static ItemData swimmingRing;

		private static int swimmingRingIndex = -1;

		internal static bool IsSwimmingRingIndex(byte itemIndex)
		{
			if (swimmingRingIndex >= 0)
			{
				return itemIndex == swimmingRingIndex;
			}
			return false;
		}

		internal static ItemData EnsureRegistered(AllItems allItems)
		{
			if (!GameApi.IsEnabled || (Object)(object)allItems == (Object)null)
			{
				return null;
			}
			GameText.RegisterSwimmingRingText();
			if ((Object)(object)swimmingRing != (Object)null && allItems.IndexOf(swimmingRing) >= 0)
			{
				swimmingRingIndex = allItems.IndexOf(swimmingRing);
				return swimmingRing;
			}
			ItemData val = FindExisting(allItems);
			if ((Object)(object)val != (Object)null)
			{
				NormalizeItem(val);
				swimmingRing = val;
				swimmingRingIndex = allItems.IndexOf(swimmingRing);
				return swimmingRing;
			}
			swimmingRing = CreateItem(allItems);
			Array.Resize(ref allItems.items, allItems.items.Length + 1);
			allItems.items[allItems.items.Length - 1] = swimmingRing;
			swimmingRingIndex = allItems.items.Length - 1;
			GameApi.Debug("Registered item: Inflatable Swimming Ring at index " + swimmingRingIndex + ".");
			return swimmingRing;
		}

		private static ItemData CreateItem(AllItems allItems)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			ItemData obj = ScriptableObject.CreateInstance<ItemData>();
			((Object)obj).name = "Inflatable Swimming Ring";
			((CraftableItemBase)obj).localizedName = SwimmingRingDefinition.NameText();
			((CraftableItemBase)obj).localizedDesc = SwimmingRingDefinition.DescriptionText();
			obj.description = "Keeps you steady in water.";
			((CraftableItemBase)obj).icon = SwimmingRingIcon.GetIcon();
			obj.equipmentType = (EquipmentType)2;
			obj.maxStackSize = 1;
			obj.durabilityLoss = (EquipmentDurabilityLossType)2;
			obj.maxDurability = 100f;
			obj.dontAllowEquipTogetherWith = (ItemData[])(object)new ItemData[0];
			obj.prefab = allItems.defaultPrefab;
			((Object)obj).hideFlags = (HideFlags)32;
			return obj;
		}

		private static ItemData FindExisting(AllItems allItems)
		{
			ItemData[] items = allItems.items;
			foreach (ItemData val in items)
			{
				if ((Object)(object)val != (Object)null && GameApi.IsSwimmingRing(val))
				{
					return val;
				}
			}
			return null;
		}

		private static void NormalizeItem(ItemData item)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			((Object)item).name = "Inflatable Swimming Ring";
			((CraftableItemBase)item).localizedName = SwimmingRingDefinition.NameText();
			((CraftableItemBase)item).localizedDesc = SwimmingRingDefinition.DescriptionText();
			item.description = "Keeps you steady in water.";
			((CraftableItemBase)item).icon = SwimmingRingIcon.GetIcon();
			item.equipmentType = (EquipmentType)2;
			item.dontAllowEquipTogetherWith = (ItemData[])(object)new ItemData[0];
		}
	}
	internal static class ModLog
	{
		private static ManualLogSource logger;

		internal static void Bind(ManualLogSource source)
		{
			logger = source;
		}

		internal static void Info(string message)
		{
			ManualLogSource obj = logger;
			if (obj != null)
			{
				obj.LogInfo((object)message);
			}
		}

		internal static void Warning(string message)
		{
			ManualLogSource obj = logger;
			if (obj != null)
			{
				obj.LogWarning((object)message);
			}
		}

		internal static void Error(string message)
		{
			ManualLogSource obj = logger;
			if (obj != null)
			{
				obj.LogError((object)message);
			}
		}
	}
	internal static class SwimmingRingAssets
	{
		private const string BundleFileName = "swimmingring.bundle";

		private const string VisualPrefabPath = "assets/prefabs/swimmingringvisual.prefab";

		private static bool loadAttempted;

		private static AssetBundle bundle;

		private static GameObject visualPrefab;

		internal static GameObject GetVisualPrefab()
		{
			return LoadVisualPrefab();
		}

		private static GameObject LoadVisualPrefab()
		{
			if (loadAttempted)
			{
				return visualPrefab;
			}
			loadAttempted = true;
			try
			{
				byte[] array = ReadBundleBytes();
				GameApi.Debug("Loading embedded AssetBundle bytes: " + array.Length + ".");
				bundle = AssetBundle.LoadFromMemory(array);
				if ((Object)(object)bundle == (Object)null)
				{
					ModLog.Warning("Embedded swimming ring bundle could not be loaded.");
					return null;
				}
				GameApi.Debug("AssetBundle.LoadFromMemory succeeded for swimmingring.bundle.");
				visualPrefab = bundle.LoadAsset<GameObject>("assets/prefabs/swimmingringvisual.prefab");
				if ((Object)(object)visualPrefab == (Object)null)
				{
					ModLog.Warning("Swimming ring visual prefab was not found at assets/prefabs/swimmingringvisual.prefab.");
					return null;
				}
				((Object)visualPrefab).name = "Inflatable Swimming Ring";
				((Object)visualPrefab).hideFlags = (HideFlags)32;
				GameApi.Debug("Loaded prefab SwimmingRingVisual from embedded swimmingring.bundle: " + ((Object)visualPrefab).name + ".");
				return visualPrefab;
			}
			catch (Exception ex)
			{
				ModLog.Warning("Swimming ring bundle failed to load: " + ex.Message);
				return null;
			}
		}

		private static byte[] ReadBundleBytes()
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = FindBundleResourceName(executingAssembly);
			if (text == null)
			{
				throw new InvalidOperationException("Missing embedded resource ending with swimmingring.bundle.");
			}
			GameApi.Debug("Using embedded bundle resource: " + text);
			using Stream stream = executingAssembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				throw new InvalidOperationException("Could not open embedded resource: " + text);
			}
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		private static string FindBundleResourceName(Assembly assembly)
		{
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (text.EndsWith("swimmingring.bundle", StringComparison.OrdinalIgnoreCase))
				{
					return text;
				}
			}
			return null;
		}
	}
	internal static class SwimmingRingIcon
	{
		private const string IconResourceFileName = "SwimmingRingIcon.png";

		private const int Size = 128;

		private static Sprite icon;

		internal static Sprite GetIcon()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)icon != (Object)null)
			{
				return icon;
			}
			icon = LoadEmbeddedIcon();
			if ((Object)(object)icon != (Object)null)
			{
				return icon;
			}
			Texture2D val = new Texture2D(128, 128, (TextureFormat)4, false);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0f, 0f, 0f, 0f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.08f, 0.34f, 0.95f, 1f);
			Color val4 = default(Color);
			((Color)(ref val4))..ctor(0.78f, 0.92f, 1f, 1f);
			Color val5 = default(Color);
			((Color)(ref val5))..ctor(0.02f, 0.08f, 0.28f, 1f);
			Vector2 val6 = default(Vector2);
			((Vector2)(ref val6))..ctor(63.5f, 63.5f);
			float num = 53.76f;
			float num2 = 28.16f;
			float num3 = 57.6f;
			for (int i = 0; i < 128; i++)
			{
				for (int j = 0; j < 128; j++)
				{
					float num4 = Vector2.Distance(new Vector2((float)j, (float)i), val6);
					Color val7 = val2;
					if (num4 <= num3 && num4 >= num2 * 0.92f)
					{
						val7 = val5;
					}
					if (num4 <= num && num4 >= num2)
					{
						val7 = ((Mathf.Sin(Mathf.Atan2((float)i - val6.y, (float)j - val6.x) * 6f) > 0.35f) ? val4 : val3);
					}
					val.SetPixel(j, i, val7);
				}
			}
			val.Apply();
			((Object)val).name = "SwimmingRingIcon";
			((Object)val).hideFlags = (HideFlags)32;
			icon = Sprite.Create(val, new Rect(0f, 0f, 128f, 128f), new Vector2(0.5f, 0.5f), 128f);
			((Object)icon).name = "SwimmingRingIcon";
			((Object)icon).hideFlags = (HideFlags)32;
			return icon;
		}

		private static Sprite LoadEmbeddedIcon()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				string text = FindIconResourceName(executingAssembly);
				if (text == null)
				{
					ModLog.Warning("Swimming ring icon resource was not found.");
					return null;
				}
				using Stream stream = executingAssembly.GetManifestResourceStream(text);
				if (stream == null)
				{
					ModLog.Warning("Swimming ring icon resource could not be opened.");
					return null;
				}
				using MemoryStream memoryStream = new MemoryStream();
				stream.CopyTo(memoryStream);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!GameApi.LoadImage(val, memoryStream.ToArray()))
				{
					ModLog.Warning("Swimming ring icon PNG could not be loaded.");
					return null;
				}
				((Object)val).name = "SwimmingRingIcon";
				((Object)val).hideFlags = (HideFlags)32;
				Sprite obj = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), (float)Mathf.Max(((Texture)val).width, ((Texture)val).height));
				((Object)obj).name = "SwimmingRingIcon";
				((Object)obj).hideFlags = (HideFlags)32;
				return obj;
			}
			catch (Exception ex)
			{
				ModLog.Warning("Swimming ring icon failed to load: " + ex.Message);
				return null;
			}
		}

		private static string FindIconResourceName(Assembly assembly)
		{
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (text.EndsWith("SwimmingRingIcon.png", StringComparison.OrdinalIgnoreCase))
				{
					return text;
				}
			}
			return null;
		}
	}
	internal static class SwimmingRingPlayerVisual
	{
		private const string PlayerVisualRootName = "SwimmingRingPlayerVisual";

		private static readonly Dictionary<int, Transform> playerVisuals = new Dictionary<int, Transform>();

		internal static void Apply(PlayerNetworking player)
		{
			if (!GameApi.IsEnabled || (Object)(object)player == (Object)null)
			{
				return;
			}
			Transform val = GetCachedPlayerVisual(player);
			if (!GameApi.HasEquippedSwimmingRing(player))
			{
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(false);
				}
				return;
			}
			bool flag = (Object)(object)val == (Object)null;
			if (flag)
			{
				GameObject visualPrefab = SwimmingRingAssets.GetVisualPrefab();
				if ((Object)(object)visualPrefab == (Object)null)
				{
					return;
				}
				GameObject obj = Object.Instantiate<GameObject>(visualPrefab, ((Component)player).transform, false);
				((Object)obj).name = "SwimmingRingPlayerVisual";
				val = obj.transform;
				playerVisuals[((Object)player).GetInstanceID()] = val;
				SwimmingRingVisualUtility.StripGameplayComponents(val);
				GameApi.Debug("Instantiated SwimmingRingPlayerVisual for player: " + ((Object)player).name + ".");
			}
			((Component)val).gameObject.SetActive(true);
			ApplyPlayerVisualTransform(val);
			if (flag)
			{
				SwimmingRingVisualUtility.PrepareVisual(val, "SwimmingRingPlayerVisual");
			}
		}

		private static Transform GetCachedPlayerVisual(PlayerNetworking player)
		{
			int instanceID = ((Object)player).GetInstanceID();
			if (!playerVisuals.TryGetValue(instanceID, out var value))
			{
				return null;
			}
			if ((Object)(object)value != (Object)null)
			{
				return value;
			}
			playerVisuals.Remove(instanceID);
			return null;
		}

		private static void ApplyPlayerVisualTransform(Transform visual)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			visual.localPosition = new Vector3(0f, PluginConfig.PlayerVisualHeightOffset.Value, PluginConfig.PlayerVisualForwardOffset.Value);
			visual.localRotation = Quaternion.identity;
			visual.localScale = Vector3.one * PluginConfig.PlayerVisualScale.Value;
		}
	}
	internal static class SwimmingRingVisualApplier
	{
		internal static void Apply(ItemInstance itemInstance)
		{
			SwimmingRingWorldVisual.Apply(itemInstance);
		}

		internal static void ApplyToPlayer(PlayerNetworking player)
		{
			SwimmingRingPlayerVisual.Apply(player);
		}
	}
	internal static class SwimmingRingVisualMaterial
	{
		private const float RuntimeSmoothness = 0.45f;

		private const string RuntimeShaderName = "Standard";

		private static readonly Color FallbackOrange = new Color(1f, 0.58f, 0.22f, 1f);

		private static Material runtimeMaterial;

		private static bool missingShaderLogged;

		internal static Material GetRuntimeMaterial(Material sourceMaterial)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)runtimeMaterial == (Object)null)
			{
				runtimeMaterial = CreateRuntimeMaterial();
				if ((Object)(object)runtimeMaterial == (Object)null)
				{
					return sourceMaterial;
				}
			}
			Texture mainTexture = GetMainTexture(sourceMaterial);
			if ((Object)(object)mainTexture != (Object)null)
			{
				SetMaterialTexture(runtimeMaterial, mainTexture);
				SetMaterialColor(runtimeMaterial, Color.white);
				return runtimeMaterial;
			}
			SetMaterialTexture(runtimeMaterial, null);
			SetMaterialColor(runtimeMaterial, FallbackOrange);
			return runtimeMaterial;
		}

		internal static string GetMaterialName(Renderer renderer)
		{
			Material sharedMaterial = renderer.sharedMaterial;
			if (!((Object)(object)sharedMaterial != (Object)null))
			{
				return "null";
			}
			return ((Object)sharedMaterial).name;
		}

		internal static string GetShaderName(Renderer renderer)
		{
			Material sharedMaterial = renderer.sharedMaterial;
			if (!((Object)(object)sharedMaterial != (Object)null) || !((Object)(object)sharedMaterial.shader != (Object)null))
			{
				return "null";
			}
			return ((Object)sharedMaterial.shader).name;
		}

		internal static string GetTextureName(Renderer renderer)
		{
			Texture mainTexture = GetMainTexture(renderer.sharedMaterial);
			if (!((Object)(object)mainTexture != (Object)null))
			{
				return "null";
			}
			return ((Object)mainTexture).name;
		}

		private static Material CreateRuntimeMaterial()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val == (Object)null)
			{
				if (!missingShaderLogged)
				{
					missingShaderLogged = true;
					ModLog.Warning("Shader not found: Standard.");
				}
				return null;
			}
			Material val2 = new Material(val);
			((Object)val2).name = "SwimmingRingRuntimeOrangeMaterial";
			SetMaterialColor(val2, FallbackOrange);
			if (val2.HasProperty("_Metallic"))
			{
				val2.SetFloat("_Metallic", 0f);
			}
			if (val2.HasProperty("_Smoothness"))
			{
				val2.SetFloat("_Smoothness", 0.45f);
			}
			GameApi.Debug("Created runtime visual material with shader: " + ((Object)val).name + ".");
			return val2;
		}

		private static void SetMaterialColor(Material material, Color color)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (material.HasProperty("_BaseColor"))
			{
				material.SetColor("_BaseColor", color);
			}
			if (material.HasProperty("_Color"))
			{
				material.SetColor("_Color", color);
			}
		}

		private static void SetMaterialTexture(Material material, Texture texture)
		{
			material.mainTexture = texture;
			if (material.HasProperty("_MainTex"))
			{
				material.SetTexture("_MainTex", texture);
			}
			if (material.HasProperty("_BaseMap"))
			{
				material.SetTexture("_BaseMap", texture);
			}
		}

		private static Texture GetMainTexture(Material material)
		{
			if ((Object)(object)material == (Object)null)
			{
				return null;
			}
			if ((Object)(object)material.mainTexture != (Object)null)
			{
				return material.mainTexture;
			}
			if (material.HasProperty("_BaseMap"))
			{
				return material.GetTexture("_BaseMap");
			}
			if (material.HasProperty("_MainTex"))
			{
				return material.GetTexture("_MainTex");
			}
			return null;
		}
	}
	internal static class SwimmingRingVisualUtility
	{
		internal static void PrepareVisual(Transform visual, string visualName)
		{
			SetActiveRecursive(visual);
			Renderer[] componentsInChildren = ((Component)visual).GetComponentsInChildren<Renderer>(true);
			GameApi.Debug(visualName + " renderer count: " + componentsInChildren.Length + ".");
			if (componentsInChildren.Length == 0)
			{
				ModLog.Warning(visualName + " has no renderers.");
				return;
			}
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.enabled = true;
					if (PluginConfig.ForceRuntimeOrangeMaterial.Value)
					{
						val.sharedMaterial = SwimmingRingVisualMaterial.GetRuntimeMaterial(val.sharedMaterial);
					}
					LogRenderer(val);
				}
			}
		}

		internal static void StripGameplayComponents(Transform visual)
		{
			Collider[] componentsInChildren = ((Component)visual).GetComponentsInChildren<Collider>(true);
			Collider[] array = componentsInChildren;
			for (int i = 0; i < array.Length; i++)
			{
				array[i].enabled = false;
			}
			Rigidbody[] componentsInChildren2 = ((Component)visual).GetComponentsInChildren<Rigidbody>(true);
			Rigidbody[] array2 = componentsInChildren2;
			for (int i = 0; i < array2.Length; i++)
			{
				Object.Destroy((Object)(object)array2[i]);
			}
			Camera[] componentsInChildren3 = ((Component)visual).GetComponentsInChildren<Camera>(true);
			Camera[] array3 = componentsInChildren3;
			for (int i = 0; i < array3.Length; i++)
			{
				((Behaviour)array3[i]).enabled = false;
			}
			Light[] componentsInChildren4 = ((Component)visual).GetComponentsInChildren<Light>(true);
			Light[] array4 = componentsInChildren4;
			for (int i = 0; i < array4.Length; i++)
			{
				((Behaviour)array4[i]).enabled = false;
			}
			GameApi.Debug("Prepared player visual components: disabled colliders=" + componentsInChildren.Length + ", removed rigidbodies=" + componentsInChildren2.Length + ", disabled cameras=" + componentsInChildren3.Length + ", disabled lights=" + componentsInChildren4.Length + ".");
		}

		private static void SetActiveRecursive(Transform root)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			((Component)root).gameObject.SetActive(true);
			foreach (Transform item in root)
			{
				SetActiveRecursive(item);
			}
		}

		private static void LogRenderer(Renderer renderer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			Bounds bounds = renderer.bounds;
			GameApi.Debug("Prepared visual renderer: " + ((Object)renderer).name + ", enabled=" + renderer.enabled + ", activeInHierarchy=" + ((Component)renderer).gameObject.activeInHierarchy + ", material=" + SwimmingRingVisualMaterial.GetMaterialName(renderer) + ", shader=" + SwimmingRingVisualMaterial.GetShaderName(renderer) + ", texture=" + SwimmingRingVisualMaterial.GetTextureName(renderer) + ", boundsCenter=" + ((object)((Bounds)(ref bounds)).center/*cast due to .constrained prefix*/).ToString() + ", boundsSize=" + ((object)((Bounds)(ref bounds)).size/*cast due to .constrained prefix*/).ToString() + ".");
		}
	}
	internal static class SwimmingRingWorldVisual
	{
		private const string VisualRootName = "SwimmingRingVisual";

		internal static void Apply(ItemInstance itemInstance)
		{
			if (!GameApi.IsEnabled || (Object)(object)itemInstance == (Object)null || !IsSwimmingRingInstance(itemInstance))
			{
				return;
			}
			GameApi.Debug("Found ItemInstance for Inflatable Swimming Ring: " + ((Object)itemInstance).name + ".");
			Transform transform = ((Component)itemInstance).transform;
			Transform val = FindExistingVisual(transform);
			HideDefaultRenderers(transform, val);
			if ((Object)(object)val != (Object)null)
			{
				ApplyWorldVisualTransform(val);
				SwimmingRingVisualUtility.PrepareVisual(val, "SwimmingRingVisual");
				return;
			}
			GameObject visualPrefab = SwimmingRingAssets.GetVisualPrefab();
			if (!((Object)(object)visualPrefab == (Object)null))
			{
				GameObject obj = Object.Instantiate<GameObject>(visualPrefab, transform, false);
				((Object)obj).name = "SwimmingRingVisual";
				ApplyWorldVisualTransform(obj.transform);
				SwimmingRingVisualUtility.PrepareVisual(obj.transform, "SwimmingRingVisual");
				GameApi.Debug("Instantiated SwimmingRingVisual for Inflatable Swimming Ring: " + ((Object)itemInstance).name + ".");
			}
		}

		private static bool IsSwimmingRingInstance(ItemInstance itemInstance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ItemRegistry.IsSwimmingRingIndex(itemInstance.InstanceData.itemIndex);
		}

		private static void HideDefaultRenderers(Transform root, Transform existingVisual)
		{
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsInsideVisual(((Component)val).transform, existingVisual))
				{
					val.enabled = false;
				}
			}
		}

		private static bool IsInsideVisual(Transform candidate, Transform existingVisual)
		{
			if ((Object)(object)existingVisual == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)candidate == (Object)(object)existingVisual))
			{
				return candidate.IsChildOf(existingVisual);
			}
			return true;
		}

		private static Transform FindExistingVisual(Transform root)
		{
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)(object)root && ((Object)val).name == "SwimmingRingVisual")
				{
					return val;
				}
			}
			return null;
		}

		private static void ApplyWorldVisualTransform(Transform visual)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			visual.localPosition = Vector3.up * PluginConfig.VisualHeightOffset.Value;
			visual.localRotation = Quaternion.identity;
			visual.localScale = Vector3.one * PluginConfig.VisualScale.Value;
		}
	}
}
namespace Joive.BurglinGnomes.SwimmingRing.Gameplay
{
	internal static class SwimmingRingMovement
	{
		private const int WaterSurfaceDetectionMask = 1;

		private const int WaterMask = 16;

		private const float InputRiseThreshold = 0.35f;

		private const float IdleInputSqrThreshold = 0.01f;

		private const float SwimAnimationMinSpeed = 0.1f;

		private static readonly int SwimSpeedParameter = Animator.StringToHash("SwimSpeed");

		internal static void Apply(NormalMovement movement, float dt)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (!GameApi.IsEnabled || !GameApi.TryGetPlayer((Component)(object)movement, out var player))
			{
				return;
			}
			SwimmingRingVisualApplier.ApplyToPlayer(player);
			if (GameApi.HasEquippedSwimmingRing(player))
			{
				if (!Utils.CheckIsInWater(player.Actor.Center, ((Component)player).transform.position, LayerMask.op_Implicit(1), LayerMask.op_Implicit(16), 0.2f))
				{
					ResetSwimAnimation(player, dt);
					return;
				}
				player.Actor.ForceNotGrounded(3);
				ApplyHorizontalSwim(player, dt);
				ApplySwimAnimation(player, dt);
				Vector3 verticalVelocity = ((PhysicsActor)player.Actor).VerticalVelocity;
				verticalVelocity.y = Mathf.Max(verticalVelocity.y, 0f - PluginConfig.MaxSinkSpeed.Value);
				verticalVelocity.y = Mathf.Min(PluginConfig.MaxRiseSpeed.Value, verticalVelocity.y + GetRiseForce(player) * dt);
				((PhysicsActor)player.Actor).VerticalVelocity = verticalVelocity;
			}
		}

		private static void ApplyHorizontalSwim(PlayerNetworking player, float dt)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			Vector3 inputMovementReference = player.StateController.InputMovementReference;
			Vector3 planarVelocity = ((PhysicsActor)player.Actor).PlanarVelocity;
			if (((Vector3)(ref inputMovementReference)).sqrMagnitude > 0.01f)
			{
				Vector3 val = ((Vector3)(ref inputMovementReference)).normalized * PluginConfig.SwimSpeed.Value;
				((PhysicsActor)player.Actor).PlanarVelocity = Vector3.MoveTowards(planarVelocity, val, PluginConfig.SwimAcceleration.Value * dt);
			}
			else
			{
				((PhysicsActor)player.Actor).PlanarVelocity = planarVelocity * PluginConfig.SwimSpeedMultiplier.Value;
			}
		}

		private static void ApplySwimAnimation(PlayerNetworking player, float dt)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			Animator animator = ((PhysicsActor)player.Actor).Animator;
			if (!((Object)(object)animator == (Object)null))
			{
				CharacterActions characterActions = player.Controller.Brain.CharacterActions;
				float sqrMagnitude = ((Vector2)(ref characterActions.movement.value)).sqrMagnitude;
				float value = PluginConfig.SwimSpeed.Value;
				Vector3 planarVelocity = ((PhysicsActor)player.Actor).PlanarVelocity;
				float num = Mathf.InverseLerp(0.1f, value, ((Vector3)(ref planarVelocity)).magnitude);
				float num2 = ((Mathf.Max(sqrMagnitude, num) > 0.01f) ? PluginConfig.SwimAnimationSpeed.Value : 0f);
				float num3 = animator.GetFloat(SwimSpeedParameter);
				animator.SetFloat(SwimSpeedParameter, Mathf.Lerp(num3, num2, PluginConfig.SwimAnimationLerp.Value * dt));
			}
		}

		private static void ResetSwimAnimation(PlayerNetworking player, float dt)
		{
			Animator animator = ((PhysicsActor)player.Actor).Animator;
			if (!((Object)(object)animator == (Object)null))
			{
				float num = animator.GetFloat(SwimSpeedParameter);
				animator.SetFloat(SwimSpeedParameter, Mathf.Lerp(num, 0f, PluginConfig.SwimAnimationLerp.Value * dt));
			}
		}

		private static float GetRiseForce(PlayerNetworking player)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			float num = PluginConfig.BuoyancyForce.Value;
			CharacterBrain brain = player.Controller.Brain;
			if (brain.CharacterActions.jump.value || brain.CharacterActions.movement.value.y > 0.35f)
			{
				num += PluginConfig.ActiveRiseForce.Value;
			}
			return num;
		}
	}
}
namespace Joive.BurglinGnomes.SwimmingRing.Config
{
	internal static class PluginConfig
	{
		private const int DefaultPlasticCost = 4;

		private const float DefaultSwimSpeedMultiplier = 0.85f;

		private const float DefaultSwimSpeed = 4.8f;

		private const float DefaultSwimAcceleration = 18f;

		private const float DefaultSwimAnimationSpeed = 1.15f;

		private const float DefaultSwimAnimationLerp = 8f;

		private const float DefaultBuoyancyForce = 18f;

		private const float DefaultActiveRiseForce = 16f;

		private const float DefaultMaxRiseSpeed = 5.5f;

		private const float DefaultMaxSinkSpeed = 0.4f;

		private const float DefaultWorldVisualScale = 6f;

		private const float DefaultWorldVisualHeightOffset = 0.25f;

		private const float DefaultPlayerVisualScale = 9f;

		private const float DefaultPlayerVisualHeightOffset = 0.35f;

		private const float DefaultPlayerVisualForwardOffset = -0.08f;

		internal static ConfigEntry<bool> EnableMod { get; private set; }

		internal static ConfigEntry<int> PlasticCost { get; private set; }

		internal static ConfigEntry<float> SwimSpeedMultiplier { get; private set; }

		internal static ConfigEntry<float> SwimSpeed { get; private set; }

		internal static ConfigEntry<float> SwimAcceleration { get; private set; }

		internal static ConfigEntry<float> SwimAnimationSpeed { get; private set; }

		internal static ConfigEntry<float> SwimAnimationLerp { get; private set; }

		internal static ConfigEntry<float> BuoyancyForce { get; private set; }

		internal static ConfigEntry<float> ActiveRiseForce { get; private set; }

		internal static ConfigEntry<float> MaxRiseSpeed { get; private set; }

		internal static ConfigEntry<float> MaxSinkSpeed { get; private set; }

		internal static ConfigEntry<float> VisualScale { get; private set; }

		internal static ConfigEntry<float> VisualHeightOffset { get; private set; }

		internal static ConfigEntry<float> PlayerVisualScale { get; private set; }

		internal static ConfigEntry<float> PlayerVisualHeightOffset { get; private set; }

		internal static ConfigEntry<float> PlayerVisualForwardOffset { get; private set; }

		internal static ConfigEntry<bool> ForceRuntimeOrangeMaterial { get; private set; }

		internal static ConfigEntry<bool> DebugLogs { get; private set; }

		internal static void Bind(ConfigFile config)
		{
			EnableMod = config.Bind<bool>("General", "EnableMod", true, "Turns the mod on.");
			PlasticCost = config.Bind<int>("Crafting", "PlasticCost", 4, "Plastic cost for the recipe.");
			SwimSpeedMultiplier = config.Bind<float>("Swimming", "SwimSpeedMultiplier", 0.85f, "Speed kept when there is no swim input.");
			SwimSpeed = config.Bind<float>("Swimming", "SwimSpeed", 4.8f, "Swim speed with the ring equipped.");
			SwimAcceleration = config.Bind<float>("Swimming", "SwimAcceleration", 18f, "How fast swim movement catches up.");
			SwimAnimationSpeed = config.Bind<float>("Swimming", "SwimAnimationSpeed", 1.15f, "Swim animation value while moving.");
			SwimAnimationLerp = config.Bind<float>("Swimming", "SwimAnimationLerp", 8f, "Swim animation blend speed.");
			BuoyancyForce = config.Bind<float>("Swimming", "BuoyancyForce", 18f, "Upward force in water.");
			ActiveRiseForce = config.Bind<float>("Swimming", "ActiveRiseForce", 16f, "Extra lift from jump or forward input.");
			MaxRiseSpeed = config.Bind<float>("Swimming", "MaxRiseSpeed", 5.5f, "Top upward speed from the ring.");
			MaxSinkSpeed = config.Bind<float>("Swimming", "MaxSinkSpeed", 0.4f, "Sink speed limit while floating.");
			VisualScale = config.Bind<float>("Visual", "VisualScale", 6f, "World item visual size.");
			VisualHeightOffset = config.Bind<float>("Visual", "VisualHeightOffset", 0.25f, "World item visual height.");
			PlayerVisualScale = config.Bind<float>("Visual", "PlayerVisualScale", 9f, "Player visual size.");
			PlayerVisualHeightOffset = config.Bind<float>("Visual", "PlayerVisualHeightOffset", 0.35f, "Player visual height.");
			PlayerVisualForwardOffset = config.Bind<float>("Visual", "PlayerVisualForwardOffset", -0.08f, "Player visual forward offset.");
			ForceRuntimeOrangeMaterial = config.Bind<bool>("Visual", "ForceRuntimeOrangeMaterial", true, "Use the runtime orange material.");
			DebugLogs = config.Bind<bool>("General", "DebugLogs", false, "Write extra setup logs.");
			if (PlayerVisualScale.Value < 9f)
			{
				PlayerVisualScale.Value = 9f;
			}
		}
	}
}