using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn.Extensions;
using Jotunn.Utils;
using UnityEngine;
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("HardheimDiving")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("HardheimDiving")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("24fb0f19-a1c4-450f-90e2-e32044a5031d")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Hardheim.Diving;

[BepInPlugin("hardheim.diving", "Hardheim Diving", "1.0.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
[SynchronizationMode(/*Could not decode attribute arguments.*/)]
public class HardheimDivingPlugin : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <InitHudDelayed>d__24 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public HardheimDivingPlugin <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <InitHudDelayed>d__24(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				((Component)<>4__this).gameObject.AddComponent<OxygenHud>();
				LogInfo("Oxygen HUD initialized.");
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public const string PluginGuid = "hardheim.diving";

	public const string PluginName = "Hardheim Diving";

	public const string PluginVersion = "1.0.1";

	internal static HardheimDivingPlugin Instance;

	internal ConfigEntry<float> RequiredSwimmingSkill;

	internal ConfigEntry<bool> UseEquipInWater;

	internal ConfigEntry<float> RestingStaminaRegenDelay;

	internal ConfigEntry<float> RestingStaminaRegenRate;

	internal ConfigEntry<float> UnderwaterRestingStaminaDrainRate;

	internal ConfigEntry<float> MaxSwimSpeed;

	internal ConfigEntry<float> ColorDarknessFactor;

	internal ConfigEntry<float> FogDensityFactor;

	internal ConfigEntry<float> MinFogDensity;

	internal ConfigEntry<float> MaxFogDensity;

	internal ConfigEntry<bool> DebugLogging;

	internal ConfigEntry<float> MaxOxygen;

	internal ConfigEntry<float> OxygenDrainPerSecond;

	internal ConfigEntry<float> OxygenRegenPerSecond;

	internal ConfigEntry<float> OxygenDamageInterval;

	internal ConfigEntry<float> OxygenDamageAmount;

	private static float currentOxygen;

	private static float oxygenDamageTimer;

	private Harmony harmony;

	private void Awake()
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Expected O, but got Unknown
		Instance = this;
		((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
		BindConfigs();
		currentOxygen = MaxOxygen.Value;
		((BaseUnityPlugin)this).Config.Save();
		((BaseUnityPlugin)this).Config.SaveOnConfigSet = true;
		harmony = new Harmony("hardheim.diving");
		harmony.PatchAll();
		((MonoBehaviour)this).StartCoroutine(InitHudDelayed());
		Game.isModded = true;
		LogInfo("Hardheim Diving 1.0.1 loaded.");
	}

	[IteratorStateMachine(typeof(<InitHudDelayed>d__24))]
	private IEnumerator InitHudDelayed()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <InitHudDelayed>d__24(0)
		{
			<>4__this = this
		};
	}

	private void OnDestroy()
	{
		Harmony obj = harmony;
		if (obj != null)
		{
			obj.UnpatchSelf();
		}
		((BaseUnityPlugin)this).Config.Save();
	}

	private void BindConfigs()
	{
		RequiredSwimmingSkill = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Hardheim", "Szükséges úszás szint", 20f, "Minimum úszás skill, ami szükséges a merülés használatához. Ez alatt a játékos csak vanilla módon úszik.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		UseEquipInWater = ConfigFileExtensions.BindConfig<bool>(((BaseUnityPlugin)this).Config, "Általános", "Eszközhasználat vízben", true, "Engedélyezi, hogy a játékos vízben is használhasson eszközöket és fegyvereket.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		RestingStaminaRegenDelay = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Stamina", "Pihenő stamina visszatöltés késleltetése", 2f, "Mennyi idő után kezdjen visszatöltődni a stamina vízben lebegés közben. A vanilla késleltetés szorzója.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		RestingStaminaRegenRate = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Stamina", "Pihenő stamina visszatöltés mértéke", 0.5f, "Milyen gyorsan töltődjön vissza a stamina vízben lebegés közben. A vanilla visszatöltés szorzója.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		UnderwaterRestingStaminaDrainRate = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Stamina", "Víz alatti stamina fogyás", 0.5f, "Milyen gyorsan fogyjon a stamina víz alatt lebegés közben. A vanilla úszás stamina fogyás szorzója.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		MaxSwimSpeed = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Mozgás", "Maximális úszási sebesség", 3f, "Maximális úszási sebesség sprintelés közben.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		ColorDarknessFactor = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Vizuális", "Sötétedés mértéke", 0.08298756f, "Milyen gyorsan sötétedjen a látvány, ahogy a játékos mélyebbre merül.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		FogDensityFactor = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Vizuális", "Köd sűrűsödés mértéke", 0f, "Milyen gyorsan sűrűsödjön a köd, ahogy a játékos mélyebbre merül.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		MinFogDensity = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Vizuális", "Minimum köd sűrűség", 0.06452283f, "A víz alatti köd minimum sűrűsége.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		MaxFogDensity = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Vizuális", "Maximum köd sűrűség", 1.518672f, "A víz alatti köd maximum sűrűsége.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		DebugLogging = ConfigFileExtensions.BindConfig<bool>(((BaseUnityPlugin)this).Config, "Debug", "Részletes logolás", false, "Részletes debug logok bekapcsolása hibakereséshez. Normál használat mellett maradjon kikapcsolva.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		MaxOxygen = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Oxigén", "Maximális oxigén", 100f, "A játékos maximális oxigén mennyisége víz alatt.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		OxygenDrainPerSecond = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Oxigén", "Oxigén fogyás másodpercenként", 1f, "Ennyi oxigén fogy másodpercenként, amikor a játékos víz alatt van.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		OxygenRegenPerSecond = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Oxigén", "Oxigén visszatöltés másodpercenként", 10f, "Ennyi oxigén töltődik vissza másodpercenként, amikor a játékos nincs víz alatt.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		OxygenDamageInterval = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Oxigén", "Fulladás sebzés időköze", 1f, "Másodpercben megadva, milyen gyakran kap sebzést a játékos, ha elfogyott az oxigénje.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		OxygenDamageAmount = ConfigFileExtensions.BindConfig<float>(((BaseUnityPlugin)this).Config, "Oxigén", "Fulladás sebzés mértéke", 5f, "Ennyi sebzést kap a játékos minden fulladás sebzésnél.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
	}

	internal bool IsEnvAllowed()
	{
		if ((Object)(object)EnvMan.instance == (Object)null)
		{
			return true;
		}
		EnvSetup currentEnvironment = EnvMan.instance.GetCurrentEnvironment();
		return currentEnvironment == null || currentEnvironment.m_name != "SunkenCrypt";
	}

	internal static bool HasRequiredSwimmingSkill(Player player)
	{
		if ((Object)(object)player == (Object)null || (Object)(object)Instance == (Object)null)
		{
			return false;
		}
		return ((Character)player).GetSkillLevel((SkillType)103) >= Instance.RequiredSwimmingSkill.Value;
	}

	internal static float GetOxygen01()
	{
		if ((Object)(object)Instance == (Object)null || Instance.MaxOxygen.Value <= 0f)
		{
			return 1f;
		}
		return Mathf.Clamp01(currentOxygen / Instance.MaxOxygen.Value);
	}

	internal static bool ShouldShowOxygenHud()
	{
		if ((Object)(object)Player.m_localPlayer == (Object)null)
		{
			return false;
		}
		if (!DivingUtils.TryGetDiver(Player.m_localPlayer, out var diver))
		{
			return false;
		}
		return ((Character)Player.m_localPlayer).InWater() && diver.HasRequiredSwimmingSkill();
	}

	internal static void HandleOxygen(Player player, Diver diver, float dt)
	{
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0190: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Expected O, but got Unknown
		//IL_01ba: 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_01c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)Instance == (Object)null || (Object)(object)player == (Object)null || (Object)(object)diver == (Object)null)
		{
			return;
		}
		float num = Mathf.Max(1f, Instance.MaxOxygen.Value);
		if (currentOxygen > num)
		{
			currentOxygen = num;
		}
		if (currentOxygen < 0f)
		{
			currentOxygen = 0f;
		}
		bool flag = diver.HasRequiredSwimmingSkill();
		bool flag2 = ((Character)player).InWater();
		bool flag3 = ZInput.GetButton("Crouch") || ZInput.GetButton("JoyCrouch");
		bool flag4 = ZInput.GetButton("Jump") || ZInput.GetButton("JoyJump");
		float liquidLevel = ((Character)player).GetLiquidLevel();
		float num2 = ((Component)player).transform.position.y + 1.55f;
		bool flag5 = num2 < liquidLevel - 0.05f;
		if (flag2 && flag && flag5 && (flag3 || flag4 || diver.IsUnderSurface() || diver.IsInsideLiquid()))
		{
			currentOxygen = Mathf.MoveTowards(currentOxygen, 0f, Instance.OxygenDrainPerSecond.Value * dt);
			if (currentOxygen <= 0f)
			{
				oxygenDamageTimer += dt;
				if (oxygenDamageTimer >= Instance.OxygenDamageInterval.Value)
				{
					oxygenDamageTimer = 0f;
					HitData val = new HitData();
					val.m_damage.m_damage = Instance.OxygenDamageAmount.Value;
					val.m_point = ((Component)player).transform.position;
					val.m_dir = Vector3.up;
					val.m_hitType = (HitType)4;
					((Character)player).Damage(val);
				}
			}
			else
			{
				oxygenDamageTimer = 0f;
			}
		}
		else
		{
			currentOxygen = Mathf.MoveTowards(currentOxygen, num, Instance.OxygenRegenPerSecond.Value * dt);
			oxygenDamageTimer = 0f;
		}
	}

	internal static void LogInfo(string msg)
	{
		HardheimDivingPlugin instance = Instance;
		if (instance != null)
		{
			((BaseUnityPlugin)instance).Logger.LogInfo((object)msg);
		}
	}

	internal static void LogDebug(string msg)
	{
		if ((Object)(object)Instance != (Object)null && Instance.DebugLogging.Value)
		{
			((BaseUnityPlugin)Instance).Logger.LogInfo((object)("[DEBUG] " + msg));
		}
	}

	internal static void LogWarning(string msg)
	{
		HardheimDivingPlugin instance = Instance;
		if (instance != null)
		{
			((BaseUnityPlugin)instance).Logger.LogWarning((object)msg);
		}
	}
}
internal class OxygenHud : MonoBehaviour
{
	private GameObject oxygenRoot;

	private GuiBar oxygenBar;

	private float retryTimer;

	private float displayedOxygen01 = 1f;

	private void Update()
	{
		if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)HardheimDivingPlugin.Instance == (Object)null)
		{
			SetVisible(visible: false);
			return;
		}
		if ((Object)(object)oxygenRoot == (Object)null || (Object)(object)oxygenBar == (Object)null)
		{
			retryTimer -= Time.deltaTime;
			if (retryTimer <= 0f)
			{
				retryTimer = 1f;
				TryCreateFromStaminaBar();
			}
			return;
		}
		bool flag = HardheimDivingPlugin.ShouldShowOxygenHud();
		SetVisible(flag);
		if (flag)
		{
			float value = HardheimDivingPlugin.Instance.MaxOxygen.Value;
			float oxygen = HardheimDivingPlugin.GetOxygen01();
			displayedOxygen01 = Mathf.MoveTowards(displayedOxygen01, oxygen, Time.deltaTime * 0.75f);
			float value2 = Mathf.Clamp(displayedOxygen01 * value, 0f, value);
			oxygenBar.SetMaxValue(value);
			oxygenBar.SetValue(value2);
		}
	}

	private void TryCreateFromStaminaBar()
	{
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)Hud.instance == (Object)null)
		{
			return;
		}
		GuiBar val = FindStaminaBar();
		if ((Object)(object)val == (Object)null)
		{
			HardheimDivingPlugin.LogInfo("Oxygen HUD: nem találtam stamina GuiBar-t.");
			return;
		}
		oxygenRoot = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.parent);
		((Object)oxygenRoot).name = "Hardheim_OxygenBar";
		oxygenRoot.SetActive(true);
		oxygenBar = oxygenRoot.GetComponent<GuiBar>();
		RectTransform component = oxygenRoot.GetComponent<RectTransform>();
		RectTransform component2 = ((Component)val).GetComponent<RectTransform>();
		if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
		{
			component.anchorMin = component2.anchorMin;
			component.anchorMax = component2.anchorMax;
			component.pivot = component2.pivot;
			component.anchoredPosition = component2.anchoredPosition + new Vector2(45f, 38f);
			((Transform)component).localScale = Vector3.one;
			((Transform)component).SetAsLastSibling();
			component.sizeDelta = new Vector2(158f, 16f);
			RectTransform[] componentsInChildren = oxygenRoot.GetComponentsInChildren<RectTransform>(true);
			foreach (RectTransform val2 in componentsInChildren)
			{
				val2.SetSizeWithCurrentAnchors((Axis)0, 158f);
			}
		}
		Image[] componentsInChildren2 = oxygenRoot.GetComponentsInChildren<Image>(true);
		foreach (Image val3 in componentsInChildren2)
		{
			if (!((Object)(object)val3 == (Object)null))
			{
				string text = ((Object)val3).name.ToLowerInvariant();
				if (!text.Contains("background") && !text.Contains("bg") && !text.Contains("border"))
				{
					((Graphic)val3).color = new Color(0.05f, 0.55f, 1f, ((Graphic)val3).color.a);
				}
			}
		}
		if ((Object)(object)oxygenBar != (Object)null)
		{
			oxygenBar.SetMaxValue(HardheimDivingPlugin.Instance.MaxOxygen.Value);
			oxygenBar.SetValue(HardheimDivingPlugin.Instance.MaxOxygen.Value);
		}
		SetVisible(visible: false);
		HardheimDivingPlugin.LogInfo("Hardheim oxigén HUD létrehozva teljes stamina panel klónból.");
	}

	private GuiBar FindStaminaBar()
	{
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: 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)
		GuiBar[] componentsInChildren = ((Component)Hud.instance).GetComponentsInChildren<GuiBar>(true);
		GuiBar val = null;
		GuiBar[] array = componentsInChildren;
		foreach (GuiBar val2 in array)
		{
			if ((Object)(object)val2 == (Object)null)
			{
				continue;
			}
			string text = GetPath(((Component)val2).transform).ToLowerInvariant();
			if (!text.Contains("hardheim_oxygenbar") && !text.Contains("mounthud") && !text.Contains("mountpanel") && !text.Contains("eitr") && !text.Contains("adrenaline") && text.Contains("hudroot/staminapanel/stamina") && text.EndsWith("stamina_fast"))
			{
				RectTransform component = ((Component)val2).GetComponent<RectTransform>();
				float num;
				Rect rect;
				if (!((Object)(object)component != (Object)null))
				{
					num = 0f;
				}
				else
				{
					rect = component.rect;
					num = ((Rect)(ref rect)).width;
				}
				float num2 = num;
				float num3;
				if (!((Object)(object)component != (Object)null))
				{
					num3 = 0f;
				}
				else
				{
					rect = component.rect;
					num3 = ((Rect)(ref rect)).height;
				}
				float num4 = num3;
				HardheimDivingPlugin.LogInfo("Player stamina GuiBar candidate: " + text + " activeInHierarchy=" + ((Component)val2).gameObject.activeInHierarchy + " width=" + num2 + " height=" + num4);
				val = val2;
				break;
			}
		}
		if ((Object)(object)val != (Object)null)
		{
			HardheimDivingPlugin.LogInfo("Oxygen HUD PLAYER stamina source: " + GetPath(((Component)val).transform));
		}
		return val;
	}

	private void SetVisible(bool visible)
	{
		if (!((Object)(object)oxygenRoot == (Object)null))
		{
			oxygenRoot.SetActive(visible);
		}
	}

	private string GetPath(Transform t)
	{
		if ((Object)(object)t == (Object)null)
		{
			return "";
		}
		string text = ((Object)t).name;
		while ((Object)(object)t.parent != (Object)null)
		{
			t = t.parent;
			text = ((Object)t).name + "/" + text;
		}
		return text;
	}
}
internal static class ReflectionFields
{
	internal static readonly FieldInfo MoveDir = AccessTools.Field(typeof(Character), "m_moveDir");

	internal static readonly FieldInfo CurrentVel = AccessTools.Field(typeof(Character), "m_currentVel");

	internal static readonly FieldInfo LastGroundTouch = AccessTools.Field(typeof(Character), "m_lastGroundTouch");

	internal static readonly FieldInfo SwimTimer = AccessTools.Field(typeof(Character), "m_swimTimer");

	internal static readonly FieldInfo SwimDepth = AccessTools.Field(typeof(Player), "m_swimDepth");

	internal static readonly FieldInfo SwimSpeed = AccessTools.Field(typeof(Player), "m_swimSpeed");

	internal static readonly FieldInfo SwimAcceleration = AccessTools.Field(typeof(Player), "m_swimAcceleration");

	internal static readonly FieldInfo SwimSkillImproveTimer = AccessTools.Field(typeof(Player), "m_swimSkillImproveTimer");

	internal static readonly FieldInfo Stamina = AccessTools.Field(typeof(Player), "m_stamina");

	internal static readonly FieldInfo StaminaRegenTimer = AccessTools.Field(typeof(Player), "m_staminaRegenTimer");

	internal static readonly FieldInfo StaminaRegen = AccessTools.Field(typeof(Player), "m_staminaRegen");

	internal static readonly FieldInfo StaminaRegenDelay = AccessTools.Field(typeof(Player), "m_staminaRegenDelay");

	internal static readonly FieldInfo SwimStaminaDrainMinSkill = AccessTools.Field(typeof(Player), "m_swimStaminaDrainMinSkill");

	internal static readonly FieldInfo SwimStaminaDrainMaxSkill = AccessTools.Field(typeof(Player), "m_swimStaminaDrainMaxSkill");

	internal static readonly FieldInfo GameCameraMinWaterDistance = AccessTools.Field(typeof(GameCamera), "m_minWaterDistance");

	internal static T Get<T>(FieldInfo field, object instance, T fallback = default(T))
	{
		if (field == null || instance == null)
		{
			return fallback;
		}
		try
		{
			object value = field.GetValue(instance);
			if (value is T)
			{
				T result = (T)value;
				if (true)
				{
					return result;
				}
			}
		}
		catch
		{
		}
		return fallback;
	}

	internal static void Set<T>(FieldInfo field, object instance, T value)
	{
		if (field == null || instance == null)
		{
			return;
		}
		try
		{
			field.SetValue(instance, value);
		}
		catch
		{
		}
	}
}
internal class Diver : MonoBehaviour
{
	private const float DefaultSwimDepth = 1.4f;

	private const float DivingSwimDepth = 2.5f;

	private static readonly Dictionary<Player, Diver> Divers = new Dictionary<Player, Diver>();

	public Player player;

	public float BaseSwimSpeed { get; private set; }

	public float RestingStaminaRegenDelay
	{
		get
		{
			float num = ReflectionFields.Get(ReflectionFields.StaminaRegenDelay, player, 1f);
			return (0f - HardheimDivingPlugin.Instance.RestingStaminaRegenDelay.Value) * num;
		}
	}

	public float RestingStaminaRegenRate
	{
		get
		{
			float num = ReflectionFields.Get(ReflectionFields.StaminaRegen, player, 1f);
			return HardheimDivingPlugin.Instance.RestingStaminaRegenRate.Value * num;
		}
	}

	private void Awake()
	{
		player = ((Component)this).GetComponent<Player>();
		if (!((Object)(object)player == (Object)null))
		{
			SetSwimDepth(1.4f);
			BaseSwimSpeed = GetSwimSpeed();
			if (!Divers.ContainsKey(player))
			{
				Divers.Add(player, this);
			}
		}
	}

	private void OnDestroy()
	{
		if ((Object)(object)player != (Object)null && Divers.ContainsKey(player))
		{
			Divers.Remove(player);
		}
	}

	public bool HasRequiredSwimmingSkill()
	{
		return HardheimDivingPlugin.HasRequiredSwimmingSkill(player);
	}

	public void ResetSwimDepthIfNotInWater()
	{
		if ((Object)(object)player == (Object)null || !((Character)player).InWater())
		{
			ResetSwimDepthToDefault();
		}
	}

	public void ResetSwimDepthToDefault()
	{
		SetSwimDepth(1.4f);
	}

	public bool CanDive()
	{
		if ((Object)(object)player == (Object)null)
		{
			return false;
		}
		if (!HasRequiredSwimmingSkill())
		{
			return false;
		}
		return ((Character)player).InWater() && !((Character)player).IsOnGround() && ((Character)player).IsSwimming();
	}

	public bool IsInsideLiquid()
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null)
		{
			return false;
		}
		return Mathf.Max(0f, ((Character)player).GetLiquidLevel() - ((Component)player).transform.position.y) > 1.4f;
	}

	public bool IsUnderSurface()
	{
		return GetSwimDepth() > 1.4f;
	}

	public bool IsDiving()
	{
		return GetSwimDepth() > 2.5f;
	}

	public bool IsSurfacing()
	{
		return !IsDiving() && IsUnderSurface();
	}

	public bool IsRestingInWater()
	{
		//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)
		int result;
		if ((Object)(object)player != (Object)null && !IsDiving() && ((Character)player).IsSwimming())
		{
			Vector3 velocity = ((Character)player).GetVelocity();
			result = ((((Vector3)(ref velocity)).magnitude < 1f) ? 1 : 0);
		}
		else
		{
			result = 0;
		}
		return (byte)result != 0;
	}

	public void RegenRestingStamina(float dt)
	{
		if (!((Object)(object)player == (Object)null))
		{
			float num = ReflectionFields.Get(ReflectionFields.StaminaRegenTimer, player, 0f);
			num -= dt;
			ReflectionFields.Set(ReflectionFields.StaminaRegenTimer, player, num);
			if (player.GetStamina() < ((Character)player).GetMaxStamina() && num <= RestingStaminaRegenDelay)
			{
				float skillFactor = ((Character)player).GetSkillFactor((SkillType)103);
				float num2 = (1f + skillFactor) * RestingStaminaRegenRate;
				float num3 = ReflectionFields.Get(ReflectionFields.Stamina, player, player.GetStamina());
				num3 = Mathf.Min(((Character)player).GetMaxStamina(), num3 + num2 * dt * Game.m_staminaRegenRate);
				ReflectionFields.Set(ReflectionFields.Stamina, player, num3);
			}
		}
	}

	public void DrainDivingStamina(float dt)
	{
	}

	public void UpdateSwimSkill(float dt)
	{
		if (!((Object)(object)player == (Object)null))
		{
			float num = ReflectionFields.Get(ReflectionFields.SwimSkillImproveTimer, player, 0f);
			num += dt;
			if (num > 1f)
			{
				num = 0f;
				((Character)player).RaiseSkill((SkillType)103, 1f);
			}
			ReflectionFields.Set(ReflectionFields.SwimSkillImproveTimer, player, num);
		}
	}

	public void UpdateSwimSpeed(float dt)
	{
		if (!((Object)(object)player == (Object)null))
		{
			float num = ((ZInput.GetButton("Run") || ZInput.GetButton("JoyRun")) ? dt : (0f - dt));
			float num2 = ReflectionFields.Get(ReflectionFields.SwimAcceleration, player, 1f);
			float num3 = GetSwimSpeed() + num2 * num;
			num3 = Mathf.Clamp(num3, BaseSwimSpeed, HardheimDivingPlugin.Instance.MaxSwimSpeed.Value);
			SetSwimSpeed(num3);
		}
	}

	public void Dive(float dt, bool ascend, out Vector3? defaultMoveDir)
	{
		//IL_0003: 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_0019: 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_0023: 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_002f: Unknown result type (might be due to invalid IL or missing references)
		defaultMoveDir = GetMoveDir();
		Vector3 diveDirection = GetDiveDirection(ascend);
		SetMoveDir(diveDirection);
		Vector3 val = CalculateSwimVelocity();
		float num = GetSwimDepth() - val.y * dt;
		SetSwimDepth(Mathf.Max(num, 1.4f));
	}

	public Vector3 GetDiveDirection(bool ascend)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: 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_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_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: 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)
		Vector3 val = (ascend ? Vector3.up : Vector3.down);
		Vector3 val2 = GetMoveDir();
		if (((Vector3)(ref val2)).magnitude < 0.1f)
		{
			float scale = ((ascend && IsSurfacing()) ? 0.6f : 0.05f);
			val2 = GetHorizontalLookDir(scale);
		}
		Vector3 result = val2 + val;
		((Vector3)(ref result)).Normalize();
		return result;
	}

	private Vector3 GetHorizontalLookDir(float scale)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: 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_002d: 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)
		Vector3 forward = ((Component)player).transform.forward;
		forward.y = 0f;
		((Vector3)(ref forward)).Normalize();
		return forward * scale;
	}

	public Vector3 CalculateSwimVelocity()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: 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_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_0041: 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)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: 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)
		float num = GetSwimSpeed();
		if (((Character)player).InMinorActionSlowdown())
		{
			num = 0f;
		}
		Vector3 moveDir = GetMoveDir();
		Vector3 val = moveDir * num;
		Vector3 val2 = ReflectionFields.Get<Vector3>(ReflectionFields.CurrentVel, player, ((Character)player).GetVelocity());
		float num2 = ReflectionFields.Get(ReflectionFields.SwimAcceleration, player, 1f);
		Vector3 result = Vector3.Lerp(val2, val, num2);
		try
		{
		}
		catch
		{
		}
		return result;
	}

	public float GetSwimDepth()
	{
		return ReflectionFields.Get(ReflectionFields.SwimDepth, player, 1.4f);
	}

	private void SetSwimDepth(float value)
	{
		ReflectionFields.Set(ReflectionFields.SwimDepth, player, value);
	}

	private float GetSwimSpeed()
	{
		return ReflectionFields.Get(ReflectionFields.SwimSpeed, player, 2f);
	}

	private void SetSwimSpeed(float value)
	{
		ReflectionFields.Set(ReflectionFields.SwimSpeed, player, value);
	}

	public Vector3 GetMoveDir()
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		return ReflectionFields.Get<Vector3>(ReflectionFields.MoveDir, player, Vector3.zero);
	}

	public void SetMoveDir(Vector3 value)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		ReflectionFields.Set<Vector3>(ReflectionFields.MoveDir, player, value);
	}
}
internal static class DivingUtils
{
	public static bool TryGetDiver(Character character, out Diver diver)
	{
		if (!IsValidLocalPlayer(character, out var player))
		{
			diver = null;
			return false;
		}
		return ((Component)player).TryGetComponent<Diver>(ref diver);
	}

	public static bool TryGetDiver(Player player, out Diver diver)
	{
		if (!IsValidLocalPlayer(player))
		{
			diver = null;
			return false;
		}
		return ((Component)player).TryGetComponent<Diver>(ref diver);
	}

	public static bool IsValidLocalPlayer(Character character, out Player player)
	{
		if ((Object)(object)character != (Object)null && character.IsPlayer() && (Object)(object)character == (Object)(object)Player.m_localPlayer)
		{
			player = Player.m_localPlayer;
			return true;
		}
		player = null;
		return false;
	}

	public static bool IsValidLocalPlayer(Player player)
	{
		return (Object)(object)player != (Object)null && (Object)(object)player == (Object)(object)Player.m_localPlayer;
	}
}
[HarmonyPatch]
internal static class DivingPatches
{
	private static bool InUpdateSwimming;

	[HarmonyPostfix]
	[HarmonyPatch(typeof(Player), "Awake")]
	private static void Player_Awake_Postfix(Player __instance)
	{
		Diver diver = default(Diver);
		if (!((Object)(object)__instance == (Object)null) && !((Component)__instance).TryGetComponent<Diver>(ref diver))
		{
			((Component)__instance).gameObject.AddComponent<Diver>();
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(Character), "UpdateMotion")]
	private static void Character_UpdateMotion_Prefix(Character __instance)
	{
		if (!DivingUtils.TryGetDiver(__instance, out var diver) || (Object)(object)HardheimDivingPlugin.Instance == (Object)null || !HardheimDivingPlugin.Instance.IsEnvAllowed())
		{
			return;
		}
		if (!diver.HasRequiredSwimmingSkill())
		{
			diver.ResetSwimDepthToDefault();
			return;
		}
		diver.ResetSwimDepthIfNotInWater();
		if (diver.IsUnderSurface() && diver.IsInsideLiquid())
		{
			ReflectionFields.Set(ReflectionFields.LastGroundTouch, diver.player, 0.3f);
			ReflectionFields.Set(ReflectionFields.SwimTimer, diver.player, 0f);
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(Character), "UpdateSwimming")]
	public static void UpdateSwimming_Prefix(Character __instance, float dt, out Vector3? __state)
	{
		InUpdateSwimming = true;
		__state = null;
		if (!DivingUtils.TryGetDiver(__instance, out var diver))
		{
			return;
		}
		if (!diver.HasRequiredSwimmingSkill())
		{
			diver.ResetSwimDepthToDefault();
			return;
		}
		diver.UpdateSwimSpeed(dt);
		if ((ZInput.GetButton("Jump") || ZInput.GetButton("JoyJump")) && diver.IsUnderSurface())
		{
			diver.Dive(dt, ascend: true, out __state);
		}
		else if ((ZInput.GetButton("Crouch") || ZInput.GetButton("JoyCrouch")) && diver.CanDive())
		{
			diver.Dive(dt, ascend: false, out __state);
		}
		else if ((__instance.IsOnGround() || !diver.IsDiving()) && !diver.IsRestingInWater())
		{
			diver.ResetSwimDepthToDefault();
		}
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(Character), "UpdateSwimming")]
	public static void UpdateSwimming_Postfix(Character __instance, float dt, ref Vector3? __state)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		InUpdateSwimming = false;
		if (__state.HasValue)
		{
			ReflectionFields.Set<Vector3>(ReflectionFields.MoveDir, __instance, __state.Value);
			__state = null;
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(Character), "UpdateRotation")]
	public static void UpdateRotation_Prefix(Character __instance, out Quaternion? __state)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		if (InUpdateSwimming)
		{
			__state = ((Component)__instance).transform.rotation;
		}
		else
		{
			__state = null;
		}
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(Character), "UpdateRotation")]
	public static void UpdateRotation_Postfix(Character __instance, float turnSpeed, float dt, ref Quaternion? __state)
	{
		//IL_002c: 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_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: 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_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
		if (InUpdateSwimming && __state.HasValue && !((Object)(object)__instance == (Object)null) && !(((Component)__instance).transform.rotation != __state.Value) && DivingUtils.TryGetDiver(__instance, out var diver) && diver.IsUnderSurface())
		{
			Player player = diver.player;
			Vector3 moveDir = diver.GetMoveDir();
			Quaternion val = ((moveDir == Vector3.zero) ? ((Component)player).transform.rotation : Quaternion.LookRotation(moveDir));
			((Component)player).transform.rotation = Quaternion.RotateTowards(((Component)player).transform.rotation, val, turnSpeed * dt);
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(Player), "OnSwimming")]
	public static void Player_OnSwimming_Prefix(Player __instance, Vector3 targetVel, float dt)
	{
		if (!(((Vector3)(ref targetVel)).magnitude >= 0.1f) && DivingUtils.TryGetDiver(__instance, out var diver) && diver.HasRequiredSwimmingSkill())
		{
			if (diver.IsDiving())
			{
				diver.DrainDivingStamina(dt);
				diver.UpdateSwimSkill(dt);
			}
			else if (diver.IsRestingInWater())
			{
				diver.RegenRestingStamina(dt);
			}
		}
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(Player), "Update")]
	private static void Player_Update_Postfix(Player __instance)
	{
		if (DivingUtils.TryGetDiver(__instance, out var diver))
		{
			HardheimDivingPlugin.HandleOxygen(__instance, diver, Time.deltaTime);
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(Player), "UseStamina")]
	private static bool Player_UseStamina_Prefix(Player __instance)
	{
		if (!DivingUtils.TryGetDiver(__instance, out var diver))
		{
			return true;
		}
		if (!diver.HasRequiredSwimmingSkill())
		{
			return true;
		}
		if (((Character)__instance).InWater() && diver.IsUnderSurface())
		{
			HardheimDivingPlugin.LogDebug("Stamina használat blokkolva víz alatt. Oxigén fogy helyette.");
			return false;
		}
		return true;
	}
}
[HarmonyPatch]
internal static class WaterCameraPatches
{
	private static float WaterLevelCamera;

	private static bool ShouldResetCamera;

	private static float? CachedMinWaterDistance;

	private const float UnderWaterCameraMinWaterDistance = -1000f;

	[HarmonyPrefix]
	[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]
	private static void GameCamera_UpdateCamera_Prefix(GameCamera __instance)
	{
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance == (Object)null || !Object.op_Implicit((Object)(object)Player.m_localPlayer) || !DivingUtils.TryGetDiver(Player.m_localPlayer, out var diver))
		{
			ResetMinWaterDistance(__instance);
			return;
		}
		if (!diver.HasRequiredSwimmingSkill() || (Object)(object)HardheimDivingPlugin.Instance == (Object)null || !HardheimDivingPlugin.Instance.IsEnvAllowed())
		{
			ResetMinWaterDistance(__instance);
			return;
		}
		bool flag = diver.IsUnderSurface() && ((Character)Player.m_localPlayer).IsSwimming();
		if (flag && !diver.IsRestingInWater())
		{
			SetMinWaterDistanceUnderWater(__instance);
		}
		else
		{
			ResetMinWaterDistance(__instance);
		}
		Camera main = Camera.main;
		if ((Object)(object)main == (Object)null)
		{
			return;
		}
		if (((Component)main).gameObject.transform.position.y < WaterLevelCamera && flag && HardheimDivingPlugin.Instance.IsEnvAllowed())
		{
			SetMinWaterDistanceUnderWater(__instance);
			if ((Object)(object)EnvMan.instance != (Object)null)
			{
				EnvSetup currentEnvironment = EnvMan.instance.GetCurrentEnvironment();
				if (currentEnvironment != null)
				{
					Color color = ((!EnvMan.IsNight()) ? currentEnvironment.m_fogColorDay : currentEnvironment.m_fogColorNight);
					color.a = 1f;
					color = ChangeColorBrightness(color, diver.GetSwimDepth() * (0f - HardheimDivingPlugin.Instance.ColorDarknessFactor.Value));
					RenderSettings.fogColor = color;
					RenderSettings.fogDensity = Mathf.Clamp(RenderSettings.fogDensity + diver.GetSwimDepth() * HardheimDivingPlugin.Instance.FogDensityFactor.Value, HardheimDivingPlugin.Instance.MinFogDensity.Value, HardheimDivingPlugin.Instance.MaxFogDensity.Value);
					ShouldResetCamera = true;
				}
			}
		}
		else if (ShouldResetCamera && ((Component)main).gameObject.transform.position.y > WaterLevelCamera && (Object)(object)EnvMan.instance != (Object)null)
		{
			EnvSetup currentEnvironment2 = EnvMan.instance.GetCurrentEnvironment();
			if (currentEnvironment2 != null)
			{
				EnvMan.instance.SetForceEnvironment(currentEnvironment2.m_name);
				EnvMan.instance.SetForceEnvironment(string.Empty);
			}
			ShouldResetCamera = false;
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(WaterVolume), "UpdateMaterials")]
	private static void WaterVolume_UpdateMaterials_Prefix(WaterVolume __instance)
	{
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)__instance == (Object)null) && Object.op_Implicit((Object)(object)GameCamera.instance) && Object.op_Implicit((Object)(object)Player.m_localPlayer) && DivingUtils.TryGetDiver(Player.m_localPlayer, out var diver) && diver.HasRequiredSwimmingSkill())
		{
			WaterLevelCamera = __instance.GetWaterSurface(((Component)GameCamera.instance).transform.position, 1f);
		}
	}

	private static void SetMinWaterDistanceUnderWater(GameCamera camera)
	{
		if (!((Object)(object)camera == (Object)null) && !(ReflectionFields.GameCameraMinWaterDistance == null))
		{
			if (!CachedMinWaterDistance.HasValue)
			{
				CachedMinWaterDistance = ReflectionFields.Get(ReflectionFields.GameCameraMinWaterDistance, camera, 0.4f);
			}
			ReflectionFields.Set(ReflectionFields.GameCameraMinWaterDistance, camera, -1000f);
		}
	}

	private static void ResetMinWaterDistance(GameCamera camera)
	{
		if (!((Object)(object)camera == (Object)null) && !(ReflectionFields.GameCameraMinWaterDistance == null) && CachedMinWaterDistance.HasValue)
		{
			ReflectionFields.Set(ReflectionFields.GameCameraMinWaterDistance, camera, CachedMinWaterDistance.Value);
		}
	}

	private static Color ChangeColorBrightness(Color color, float correctionFactor)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: 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_0029: 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)
		//IL_00a1: 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_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		float r = color.r;
		float g = color.g;
		float b = color.b;
		if (correctionFactor >= 0f)
		{
			return new Color(r, g, b, color.a);
		}
		correctionFactor *= -1f;
		r -= r * correctionFactor;
		g -= g * correctionFactor;
		b -= b * correctionFactor;
		if (r < 0f)
		{
			r = 0f;
		}
		if (g < 0f)
		{
			g = 0f;
		}
		if (b < 0f)
		{
			b = 0f;
		}
		return new Color(r, g, b, color.a);
	}
}
[HarmonyPatch]
internal static class UseEquipPatches
{
	private static readonly CodeMatch[] CodeMatches = (CodeMatch[])(object)new CodeMatch[5]
	{
		new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
		new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Character), "IsSwimming", (Type[])null, (Type[])null), (string)null),
		new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null),
		new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
		new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Character), "IsOnGround", (Type[])null, (Type[])null), (string)null)
	};

	private static readonly int InstructionMatchCount = CodeMatches.Length + 1;

	private static bool ShouldHideItem()
	{
		return (Object)(object)HardheimDivingPlugin.Instance != (Object)null && !HardheimDivingPlugin.Instance.UseEquipInWater.Value;
	}

	[HarmonyTranspiler]
	[HarmonyPatch(typeof(Humanoid), "UpdateEquipment")]
	private static IEnumerable<CodeInstruction> UpdateEquipment_Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		return PatchSwimmingEquipmentCheck(instructions, "Humanoid.UpdateEquipment");
	}

	[HarmonyTranspiler]
	[HarmonyPatch(typeof(Humanoid), "EquipItem")]
	private static IEnumerable<CodeInstruction> EquipItem_Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		return PatchSwimmingEquipmentCheck(instructions, "Humanoid.EquipItem");
	}

	[HarmonyTranspiler]
	[HarmonyPatch(typeof(Player), "Update")]
	private static IEnumerable<CodeInstruction> UpdatePlayer_Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Expected O, but got Unknown
		CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
		val.MatchStartForward(CodeMatches);
		if (!val.IsValid)
		{
			HardheimDivingPlugin.LogWarning("Failed to patch Player.Update equipment swimming check.");
			return instructions;
		}
		val.Advance(1);
		val.RemoveInstructions(InstructionMatchCount);
		return val.InstructionEnumeration();
	}

	private static IEnumerable<CodeInstruction> PatchSwimmingEquipmentCheck(IEnumerable<CodeInstruction> instructions, string methodName)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Expected O, but got Unknown
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Expected O, but got Unknown
		CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
		val.MatchStartForward(CodeMatches);
		if (!val.IsValid)
		{
			HardheimDivingPlugin.LogWarning("Failed to patch " + methodName + " equipment swimming check.");
			return instructions;
		}
		val.Advance(InstructionMatchCount);
		val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
		{
			Transpilers.EmitDelegate<Func<bool>>((Func<bool>)ShouldHideItem),
			new CodeInstruction(OpCodes.Brfalse, val.InstructionAt(-1).operand)
		});
		return val.InstructionEnumeration();
	}
}