using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyCompany("Cjayride.Vigor")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Cjayride.Vigor")]
[assembly: AssemblyTitle("Cjayride.Vigor")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[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 Cjayride.Vigor
{
	public class ConfigurationManagerAttributes
	{
		public bool? IsAdminOnly;
	}
	internal static class ConstitutionLayer
	{
		[HarmonyPatch(typeof(Player), "GetBaseFoodHP")]
		private static class BaseFoodHpPatch
		{
			private static void Postfix(Player __instance, ref float __result)
			{
				__result += ExtraHealth(__instance);
			}
		}

		[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
		private static class TotalFoodValuePatch
		{
			private static void Postfix(Player __instance, ref float hp, ref float stamina)
			{
				hp += ExtraHealth(__instance);
				stamina += ExtraStamina(__instance);
			}
		}

		[HarmonyPatch(typeof(Player), "UpdateFood")]
		private static class UpdateFoodPatch
		{
			private static void Prefix(Player __instance)
			{
				if (foodUpdate >= 1500 || __instance.m_foods.Count == 0 || ++foodUpdate % 50 != 0)
				{
					return;
				}
				foreach (Food food in __instance.m_foods)
				{
					ItemData item = food.m_item;
					skillRaise += (item.m_shared.m_food * VigorConfig.ConFoodHealthGain.Value + item.m_shared.m_foodStamina * VigorConfig.ConFoodStaminaGain.Value) / item.m_shared.m_foodBurnTime;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UseStamina")]
		private static class UseStaminaPatch
		{
			private static void Prefix(Player __instance, float v)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				if (foodUpdate < 1500 || v <= 0f || skillRaise <= 0f)
				{
					return;
				}
				float num = ((Character)__instance).GetSkills().GetSkill(Plugin.ConstitutionSkill).m_level * VigorConfig.ConActivityToSkill.Value;
				stamUsage += v;
				if (!(stamUsage < num))
				{
					if (((Character)__instance).GetSkills().GetSkill(Plugin.ConstitutionSkill).m_level < 100f && skillRaise > 0f)
					{
						((Character)__instance).RaiseSkill(Plugin.ConstitutionSkill, (float)Math.Round(skillRaise, 2));
					}
					foodUpdate = 0;
					stamUsage = 0f;
					skillRaise = 0f;
				}
			}
		}

		private static float stamUsage;

		private static float skillRaise;

		private static int foodUpdate;

		internal static float ExtraHealth(Player player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Skill skill = ((Character)player).GetSkills().GetSkill(Plugin.ConstitutionSkill);
			return VigorConfig.ConBaseHealth.Value + skill.m_level * VigorConfig.ConHealthPerPoint.Value;
		}

		internal static float ExtraStamina(Player player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Skill skill = ((Character)player).GetSkills().GetSkill(Plugin.ConstitutionSkill);
			return VigorConfig.ConBaseStamina.Value + skill.m_level * VigorConfig.ConStaminaPerPoint.Value;
		}
	}
	[BepInPlugin("cjayride.vigor", "Cjayride Vigor", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("VitalityRewrite")]
	[BepInIncompatibility("papajin68.constitution")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGUID = "cjayride.vigor";

		public const string PluginName = "Cjayride Vigor";

		public const string PluginVersion = "1.0.0";

		public const string VitalityId = "cjayride.vigor.vitality";

		public const string ConstitutionId = "cjayride.vigor.constitution";

		internal static Plugin Instance;

		internal static Harmony Harmony;

		internal static SkillType VitalitySkill;

		internal static SkillType ConstitutionSkill;

		private void Awake()
		{
			//IL_0016: 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_0031: 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_004c: Expected O, but got Unknown
			//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)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			VigorConfig.Bind(((BaseUnityPlugin)this).Config);
			VitalitySkill = SkillManager.Instance.AddSkill(new SkillConfig
			{
				Identifier = "cjayride.vigor.vitality",
				Name = "Vitality",
				Description = "Travel and hard labor raise your base body. Stacks with Constitution.",
				IncreaseStep = 1f
			});
			ConstitutionSkill = SkillManager.Instance.AddSkill(new SkillConfig
			{
				Identifier = "cjayride.vigor.constitution",
				Name = "Constitution",
				Description = "Honest meals and spent stamina harden the body. Stacks with Vitality.",
				IncreaseStep = 1f
			});
			Harmony = new Harmony("cjayride.vigor");
			Harmony.PatchAll(Assembly.GetExecutingAssembly());
			new ConsoleCommand("vigor", "reload | apply — Vigor config", (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				if (args.Length >= 2)
				{
					string text = args[1].ToLowerInvariant();
					if (text == "reload")
					{
						((BaseUnityPlugin)this).Config.Reload();
					}
					if (text == "reload" || text == "apply")
					{
						VitalityLayer.ApplyAllPlayers();
						args.Context.AddString("Vigor: config applied");
					}
				}
			}, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			Logger.LogInfo((object)"Cjayride Vigor 1.0.0 loaded (Vitality + Constitution).");
		}

		internal static void Log(string message)
		{
			if (VigorConfig.LoggingEnabled != null && VigorConfig.LoggingEnabled.Value)
			{
				((BaseUnityPlugin)Instance).Logger.LogInfo((object)message);
			}
		}
	}
	internal static class VigorConfig
	{
		internal static ConfigEntry<bool> LoggingEnabled;

		internal static ConfigEntry<float> ConBaseHealth;

		internal static ConfigEntry<float> ConBaseStamina;

		internal static ConfigEntry<float> ConFoodHealthGain;

		internal static ConfigEntry<float> ConFoodStaminaGain;

		internal static ConfigEntry<float> ConHealthPerPoint;

		internal static ConfigEntry<float> ConStaminaPerPoint;

		internal static ConfigEntry<float> ConActivityToSkill;

		internal static ConfigEntry<float> VitMaxHealth;

		internal static ConfigEntry<float> VitHealthRegen;

		internal static ConfigEntry<float> VitMaxStamina;

		internal static ConfigEntry<float> VitMaxEitr;

		internal static ConfigEntry<float> VitStaminaRegen;

		internal static ConfigEntry<float> VitEitrRegen;

		internal static ConfigEntry<float> VitStaminaDelay;

		internal static ConfigEntry<float> VitJumpCost;

		internal static ConfigEntry<float> VitSwimCost;

		internal static ConfigEntry<float> VitWalkSpeed;

		internal static ConfigEntry<float> VitRunSpeed;

		internal static ConfigEntry<float> VitSwimSpeed;

		internal static ConfigEntry<float> VitCarry;

		internal static ConfigEntry<float> VitJumpHeight;

		internal static ConfigEntry<float> VitFallDamage;

		internal static ConfigEntry<bool> VitDoubleJumpFallReset;

		internal static ConfigEntry<float> VitWoodcutting;

		internal static ConfigEntry<float> VitMining;

		internal static ConfigEntry<float> VitSkillGain;

		internal static ConfigEntry<float> VitWorkDamageGain;

		private static ConfigDescription Admin(string desc)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new ConfigDescription(desc, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdminOnly = true
				}
			});
		}

		internal static void Bind(ConfigFile config)
		{
			LoggingEnabled = config.Bind<bool>("Logging", "Logging Enabled", false, "Enable extra Vigor log lines.");
			ConBaseHealth = config.Bind<float>("Constitution", "BaseHealthAdjust", 10f, Admin("Health added to the base pool (pack default)."));
			ConBaseStamina = config.Bind<float>("Constitution", "BaseStaminaAdjust", 10f, Admin("Stamina added to the base pool (pack default)."));
			ConFoodHealthGain = config.Bind<float>("Constitution", "ConstitutionGainHealthModifier", 0.2f, Admin("Food-health constitution XP. Pack used 0.2 (upstream default 0.25)."));
			ConFoodStaminaGain = config.Bind<float>("Constitution", "ConstitutionGainStaminaModifier", 0.2f, Admin("Food-stamina constitution XP. Pack used 0.2."));
			ConHealthPerPoint = config.Bind<float>("Constitution", "HealthPerConstitution", 0.5f, Admin("Health per constitution level."));
			ConStaminaPerPoint = config.Bind<float>("Constitution", "StaminaPerConstitution", 0.5f, Admin("Stamina per constitution level."));
			ConActivityToSkill = config.Bind<float>("Constitution", "ActivityToSkillModifer", 1f, Admin("Stamina that must be spent (as a fraction of current skill) before food XP applies."));
			VitMaxHealth = config.Bind<float>("Vitality", "MaxIncrease", 125f, Admin("Extra max health at vitality 100."));
			VitHealthRegen = config.Bind<float>("Vitality", "RegenerationIncrease", 100f, Admin("Health regen increase % at vitality 100."));
			VitMaxStamina = config.Bind<float>("Vitality", "MaxStaminaIncrease", 150f, Admin("Extra max stamina at vitality 100. Pack used 150 (upstream 40)."));
			VitMaxEitr = config.Bind<float>("Vitality", "MaxEitrIncrease", 40f, Admin("Extra max eitr at vitality 100 if food eitr > 0."));
			VitStaminaRegen = config.Bind<float>("Vitality", "StaminaRegenerationIncrease", 24f, Admin("Stamina regen increase % at vitality 100. Pack used 24 (upstream 72)."));
			VitEitrRegen = config.Bind<float>("Vitality", "EitrRegenerationIncrease", 72f, Admin("Eitr regen increase % at vitality 100."));
			VitStaminaDelay = config.Bind<float>("Vitality", "RegenerationDelayReduction", 50f, Admin("Stamina regen delay reduction % at vitality 100."));
			VitJumpCost = config.Bind<float>("Vitality", "JumpCostReduction", 50f, Admin("Jump stamina cost reduction % at vitality 100. Pack used 50."));
			VitSwimCost = config.Bind<float>("Vitality", "SwimCostReduction", 75f, Admin("Swim stamina cost reduction % at vitality 100. Pack used 75."));
			VitWalkSpeed = config.Bind<float>("Vitality", "WalkingBase", 12.5f, Admin("Walk speed increase at vitality 100."));
			VitRunSpeed = config.Bind<float>("Vitality", "RunBase", 12.5f, Admin("Run speed increase at vitality 100."));
			VitSwimSpeed = config.Bind<float>("Vitality", "SwimBase", 100f, Admin("Swim speed increase % at vitality 100."));
			VitCarry = config.Bind<float>("Vitality", "Carryweight", 400f, Admin("Extra carry weight at vitality 100."));
			VitJumpHeight = config.Bind<float>("Vitality", "JumpHeight", 10f, Admin("Jump height increase % at vitality 100."));
			VitFallDamage = config.Bind<float>("Vitality", "FallDamageReduction", 10f, Admin("Fall damage reduction % at vitality 100."));
			VitDoubleJumpFallReset = config.Bind<bool>("Vitality", "DoubleJumpFallDamageReset", true, Admin("Reset fall height on jump (EpicLoot air jump)."));
			VitWoodcutting = config.Bind<float>("Vitality", "WoodcuttingIncrease", 25f, Admin("Chop damage increase % at vitality 100."));
			VitMining = config.Bind<float>("Vitality", "MiningIncrease", 25f, Admin("Pickaxe damage increase % at vitality 100."));
			VitSkillGain = config.Bind<float>("Vitality", "GeneralMultiplier", 1f, Admin("Vitality XP multiplier."));
			VitWorkDamageGain = config.Bind<float>("Vitality", "WorkDamageMultiplier", 1f, Admin("Extra vitality XP from tool damage."));
		}
	}
	internal static class VitalityLayer
	{
		[HarmonyPatch(typeof(Player), "UpdateFood")]
		private static class HealthRegenPatch
		{
			private static void Prefix(ref float ___m_foodRegenTimer)
			{
				if (___m_foodRegenTimer == 0f)
				{
					float num = skillFactor * VigorConfig.VitHealthRegen.Value / 100f + 1f;
					if (num > 0f)
					{
						___m_foodRegenTimer = 10f - 10f / num;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "SetMaxHealth")]
		private static class MaxHealthPatch
		{
			private static void Prefix(ref float health)
			{
				health += skillFactor * VigorConfig.VitMaxHealth.Value;
			}
		}

		[HarmonyPatch(typeof(Player), "SetMaxStamina")]
		private static class MaxStaminaPatch
		{
			private static void Prefix(ref float stamina)
			{
				stamina += skillFactor * VigorConfig.VitMaxStamina.Value;
			}
		}

		[HarmonyPatch(typeof(Player), "SetMaxEitr")]
		private static class MaxEitrPatch
		{
			private static void Prefix(ref float eitr)
			{
				if (eitr > 0f)
				{
					eitr += skillFactor * VigorConfig.VitMaxEitr.Value;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetJogSpeedFactor")]
		private static class WalkSpeedPatch
		{
			private static void Postfix(ref float __result)
			{
				__result += skillFactor * VigorConfig.VitWalkSpeed.Value / 100f;
			}
		}

		[HarmonyPatch(typeof(Player), "GetRunSpeedFactor")]
		private static class RunSpeedPatch
		{
			private static void Postfix(ref float __result)
			{
				__result += skillFactor * VigorConfig.VitRunSpeed.Value / 100f;
			}
		}

		[HarmonyPatch(typeof(Character), "UpdateGroundContact")]
		private static class FallDamagePatch
		{
			private static void Prefix(Character __instance, ref float ___m_maxAirAltitude, bool ___m_groundContact)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.IsPlayer() && ___m_groundContact)
				{
					float num = ___m_maxAirAltitude - ((Component)__instance).transform.position.y;
					if (num > 4f)
					{
						___m_maxAirAltitude -= num * skillFactor * VigorConfig.VitFallDamage.Value / 100f;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnJump")]
		private static class JumpPatch
		{
			private static void Prefix(Player __instance)
			{
				float num = ((Character)__instance).m_jumpStaminaUsage - ((Character)__instance).m_jumpStaminaUsage * ((Character)__instance).GetEquipmentJumpStaminaModifier();
				if (((Character)__instance).HaveStamina(num * Game.m_moveStaminaRate))
				{
					Gain(__instance, 0.14f);
				}
			}

			private static void Postfix(Player __instance, ref float ___m_maxAirAltitude)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				if (VigorConfig.VitDoubleJumpFallReset.Value)
				{
					___m_maxAirAltitude = ((Component)__instance).transform.position.y;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UpdateStats", new Type[] { typeof(float) })]
		private static class UpdateStatsPatch
		{
			private static void Prefix(Player __instance, float dt)
			{
				if (((Character)__instance).IsFlying())
				{
					return;
				}
				if (((Character)__instance).IsRunning() && ((Character)__instance).IsOnGround())
				{
					runSwimSkill += 0.1f * dt;
				}
				if (((Character)__instance).InWater() && !((Character)__instance).IsOnGround())
				{
					float staminaPercentage = ((Character)__instance).GetStaminaPercentage();
					if (!Mathf.Approximately(lastSwimStamina, staminaPercentage))
					{
						runSwimSkill += 0.25f * dt;
					}
					lastSwimStamina = staminaPercentage;
				}
				if (runSwimSkill >= 1f)
				{
					Gain(__instance, runSwimSkill);
					runSwimSkill = 0f;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		private static class LoadPatch
		{
			private static void Postfix(Player __instance)
			{
				captured = false;
				Apply(__instance);
			}
		}

		[HarmonyPatch(typeof(Player), "OnSkillLevelup")]
		private static class LevelUpPatch
		{
			private static void Postfix(Player __instance, SkillType skill)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				if (skill == Plugin.VitalitySkill)
				{
					Apply(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(MineRock5), "DamageArea")]
		private static class MineRockPatch
		{
			private static void Prefix(MineRock5 __instance, HitData hit)
			{
				//IL_0010: 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_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Invalid comparison between Unknown and I4
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && !(((Character)localPlayer).GetZDOID() != hit.m_attacker) && (int)hit.m_skill == 12)
				{
					hit.m_damage.m_pickaxe *= 1f + skillFactor * VigorConfig.VitMining.Value / 100f;
					Gain(localPlayer, 0.04f + hit.m_damage.m_pickaxe * 0.00075f * VigorConfig.VitWorkDamageGain.Value);
					Plugin.Log($"MineRock5 {((Object)__instance).name} dmg={hit.m_damage.m_pickaxe}");
				}
			}
		}

		[HarmonyPatch(typeof(Destructible), "Damage")]
		private static class DestructiblePatch
		{
			private static void Prefix(Destructible __instance, HitData hit)
			{
				//IL_0010: 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_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Invalid comparison between Unknown and I4
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Invalid comparison between Unknown and I4
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && !(((Character)localPlayer).GetZDOID() != hit.m_attacker))
				{
					if (((Object)__instance).name.ToLowerInvariant().Contains("rock") && (int)hit.m_skill == 12)
					{
						hit.m_damage.m_pickaxe *= 1f + skillFactor * VigorConfig.VitMining.Value / 100f;
						Gain(localPlayer, 0.1f + hit.m_damage.m_pickaxe * 0.001f * VigorConfig.VitWorkDamageGain.Value);
					}
					else if ((int)hit.m_skill == 13)
					{
						hit.m_damage.m_chop *= 1f + skillFactor * VigorConfig.VitWoodcutting.Value / 100f;
						Gain(localPlayer, 0.1f + hit.m_damage.m_chop * 0.001f * VigorConfig.VitWorkDamageGain.Value);
					}
				}
			}
		}

		[HarmonyPatch(typeof(TreeBase), "Damage")]
		private static class TreePatch
		{
			private static void Prefix(TreeBase __instance, HitData hit)
			{
				//IL_0010: 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_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Invalid comparison between Unknown and I4
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && !(((Character)localPlayer).GetZDOID() != hit.m_attacker) && (int)hit.m_skill == 13 && hit.m_toolTier >= __instance.m_minToolTier)
				{
					hit.m_damage.m_chop *= 1f + skillFactor * VigorConfig.VitWoodcutting.Value / 100f;
					Gain(localPlayer, 0.1f + hit.m_damage.m_chop * 0.001f * VigorConfig.VitWorkDamageGain.Value);
				}
			}
		}

		[HarmonyPatch(typeof(TreeLog), "Damage")]
		private static class TreeLogPatch
		{
			private static void Prefix(TreeLog __instance, HitData hit)
			{
				//IL_0010: 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_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Invalid comparison between Unknown and I4
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && !(((Character)localPlayer).GetZDOID() != hit.m_attacker) && (int)hit.m_skill == 13 && hit.m_toolTier >= __instance.m_minToolTier)
				{
					hit.m_damage.m_chop *= 1f + skillFactor * VigorConfig.VitWoodcutting.Value / 100f;
					Gain(localPlayer, 0.1f + hit.m_damage.m_chop * 0.001f * VigorConfig.VitWorkDamageGain.Value);
				}
			}
		}

		private static float skillFactor;

		private static float runSwimSkill;

		private static float lastSwimStamina;

		private static float baseJumpForce;

		private static float baseMaxCarry;

		private static float baseJumpStamina;

		private static float baseStaminaDelay;

		private static float baseStaminaRegen;

		private static float baseEitrRegen;

		private static float baseSwimDrainMin;

		private static float baseSwimDrainMax;

		private static float baseSwimSpeed;

		private static float baseSwimTurn;

		private static bool captured;

		internal static void ApplyAllPlayers()
		{
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				Apply(allPlayer);
			}
		}

		internal static void Apply(Player player)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null))
			{
				if (!captured)
				{
					Capture(player);
				}
				skillFactor = ((Character)player).GetSkillFactor(Plugin.VitalitySkill);
				Plugin.Log($"Vitality skillFactor={skillFactor}");
				((Character)player).m_jumpForce = baseJumpForce * (1f + skillFactor * VigorConfig.VitJumpHeight.Value / 100f);
				player.m_staminaRegen = baseStaminaRegen * (1f + skillFactor * VigorConfig.VitStaminaRegen.Value / 100f);
				SetEitrRegen(player, baseEitrRegen * (1f + skillFactor * VigorConfig.VitEitrRegen.Value / 100f));
				player.m_swimStaminaDrainMinSkill = baseSwimDrainMin * (1f - skillFactor * VigorConfig.VitSwimCost.Value / 100f);
				player.m_swimStaminaDrainMaxSkill = baseSwimDrainMax * (1f - skillFactor * VigorConfig.VitSwimCost.Value / 100f);
				player.m_maxCarryWeight = baseMaxCarry + skillFactor * VigorConfig.VitCarry.Value;
				((Character)player).m_jumpStaminaUsage = baseJumpStamina * (1f - skillFactor * VigorConfig.VitJumpCost.Value / 100f);
				player.m_staminaRegenDelay = baseStaminaDelay * (1f - skillFactor * VigorConfig.VitStaminaDelay.Value / 100f);
				((Character)player).m_swimSpeed = baseSwimSpeed * (1f + skillFactor * VigorConfig.VitSwimSpeed.Value / 100f);
				((Character)player).m_swimTurnSpeed = baseSwimTurn * (1f + skillFactor * VigorConfig.VitSwimSpeed.Value / 100f);
			}
		}

		private static void Capture(Player player)
		{
			baseJumpForce = ((Character)player).m_jumpForce;
			baseStaminaRegen = player.m_staminaRegen;
			baseEitrRegen = GetEitrRegen(player);
			baseSwimDrainMin = player.m_swimStaminaDrainMinSkill;
			baseSwimDrainMax = player.m_swimStaminaDrainMaxSkill;
			baseMaxCarry = player.m_maxCarryWeight;
			baseJumpStamina = ((Character)player).m_jumpStaminaUsage;
			baseStaminaDelay = player.m_staminaRegenDelay;
			baseSwimSpeed = ((Character)player).m_swimSpeed;
			baseSwimTurn = ((Character)player).m_swimTurnSpeed;
			captured = true;
		}

		private static float GetEitrRegen(Player player)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(Player), "m_eitrRegen") ?? AccessTools.Field(typeof(Player), "m_eiterRegen");
			if (!(fieldInfo != null))
			{
				return 0f;
			}
			return (float)fieldInfo.GetValue(player);
		}

		private static void SetEitrRegen(Player player, float value)
		{
			(AccessTools.Field(typeof(Player), "m_eitrRegen") ?? AccessTools.Field(typeof(Player), "m_eiterRegen"))?.SetValue(player, value);
		}

		private static void Gain(Player player, float value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((Character)player).RaiseSkill(Plugin.VitalitySkill, value * VigorConfig.VitSkillGain.Value);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}