using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using PEAKLib.UI;
using PEAKLib.UI.Elements;
using PEAKUsageSkills.Config;
using PEAKUsageSkills.Core;
using PEAKUsageSkills.Diagnostics;
using PEAKUsageSkills.Effects;
using PEAKUsageSkills.GameAdapters;
using PEAKUsageSkills.GameAdapters.Patches;
using PEAKUsageSkills.Localization;
using PEAKUsageSkills.Persistence;
using PEAKUsageSkills.Tracking;
using PEAKUsageSkills.UI;
using Peak.Afflictions;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.Core.Serizalization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PEAKUsageSkills")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.4.7.0")]
[assembly: AssemblyInformationalVersion("0.4.7+ff2a3c774b0d6323303de590055096131c3b177a")]
[assembly: AssemblyProduct("PEAKUsageSkills")]
[assembly: AssemblyTitle("PEAKUsageSkills")]
[assembly: AssemblyVersion("0.4.7.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[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 PEAKUsageSkills
{
	[BepInPlugin("com.chiseled.peak.usageskills", "Elin's PEAK", "0.4.7")]
	[BepInProcess("PEAK.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.chiseled.peak.usageskills";

		public const string PluginName = "Elin's PEAK";

		public const string PluginVersion = "0.4.7";

		private Harmony? harmony;

		internal static UsageSkillsConfig Settings { get; private set; }

		internal static RunStateAdapter RunState { get; private set; }

		internal static ProgressionService Progression { get; private set; }

		internal static EffectService Effects { get; private set; }

		internal static DiagnosticHub? Diagnostics { get; private set; }

		internal static ManualLogSource ModLog { get; private set; }

		private void Awake()
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			ModLog = ((BaseUnityPlugin)this).Logger;
			Settings = new UsageSkillsConfig(((BaseUnityPlugin)this).Config);
			LocalizationService.Initialize(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location) ?? Paths.PluginPath);
			RunState = new RunStateAdapter(Settings);
			SaveStore store = new SaveStore(((BaseUnityPlugin)this).Logger);
			Progression = new ProgressionService(Settings, store, ((BaseUnityPlugin)this).Logger, RunState);
			Effects = new EffectService(Settings, Progression, RunState);
			Diagnostics = new DiagnosticHub(((BaseUnityPlugin)this).Logger, Settings, RunState, Progression, Effects);
			Progression.LevelChanged += OnSkillLevelChanged;
			harmony = new Harmony("com.chiseled.peak.usageskills");
			PatchAllFailSoft(Assembly.GetExecutingAssembly());
			((Component)this).gameObject.AddComponent<ActivitySampler>();
			((Component)this).gameObject.AddComponent<InventorySkillController>();
			((Component)this).gameObject.AddComponent<DebugOverlay>();
			PauseMenuIntegration.Register();
			SceneManager.sceneLoaded += OnSceneLoaded;
			InspectPatchHealth();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Elin's PEAK 0.4.7 loaded. Save levels are player-owned; Airport XP is disabled and anti-farming policy is deferred for the first runtime pass.");
		}

		private void Update()
		{
			Progression.Tick();
			Diagnostics?.Tick();
		}

		private void OnApplicationQuit()
		{
			Progression.Flush();
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			Progression.LevelChanged -= OnSkillLevelChanged;
			PauseMenuIntegration.Unregister();
			LocalizationService.Shutdown();
			Progression.Flush();
			Harmony? obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Progression.Flush();
			ModLog.LogInfo((object)$"[UsageSkills:Scene] loaded={((Scene)(ref scene)).name} mode={mode} xpEligible={RunState.IsExperienceEligible}");
		}

		private static void OnSkillLevelChanged(SkillId skillId, int level)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (skillId == SkillId.Strength && Settings.DebugAllSkillLevelOverride.Value < 0)
			{
				WeightPatch.RefreshLocalWeight($"StrengthLevel:{level}");
				InventorySkillService.EnsureBackpackCapacity(InventorySkillService.TryGetEquippedBackpackData(Character.localCharacter, out var backpackType), backpackType, $"StrengthLevel:{level}");
			}
		}

		private static void InspectPatchHealth()
		{
			RecordHook("StaminaCapacity", typeof(Character), "GetMaxStamina");
			RecordHook("PassOutThreshold", typeof(CharacterAfflictions), "get_shouldPassOut");
			RecordHook("PassOutRecovery", typeof(Character), "HandlePassedOut");
			RecordHook("StaminaCost", typeof(Character), "UseStamina");
			RecordHook("StaminaRegen", typeof(Character), "UpdateVariablesFixed");
			RecordHook("StaminaHud", typeof(StaminaBar), "Update");
			RecordHook("Weight", typeof(CharacterAfflictions), "UpdateWeight");
			RecordHook("WallClimbing", typeof(CharacterClimbing), "GetRequestedPostition");
			RecordHook("RopeClimbing", typeof(CharacterRopeHandling), "Update");
			RecordHook("VineClimbing", typeof(CharacterVineClimbing), "FixedUpdate");
			RecordHook("Athletics", typeof(CharacterMovement), "GetMovementForce");
			RecordHook("Agility", typeof(CharacterMovement), "JumpRpc");
			RecordHook("NormalFalls", typeof(CharacterMovement), "CheckFallDamage");
			RecordHook("WallFalls", typeof(CharacterClimbing), "CheckFallDamage");
			RecordHook("Afflictions", typeof(CharacterAfflictions), "AddStatus");
			RecordHook("ConditionRecovery", typeof(CharacterAfflictions), "SubtractStatus");
			RecordHook("Petrification", typeof(CharacterAfflictions), "AddPetrify", new Type[1] { typeof(int) });
			RecordHook("BackpackInventory", typeof(BackpackData), "DeserializeValue");
			RecordHook("BackpackWheel", typeof(BackpackWheel), "InitWheel");
			RecordHook("WetGrip", typeof(WindChillZone), "ApplyStatus");
		}

		private void PatchAllFailSoft(Assembly assembly)
		{
			Type[] types = assembly.GetTypes();
			Array.Sort(types, (Type left, Type right) => string.CompareOrdinal(left.FullName, right.FullName));
			Type[] array = types;
			foreach (Type type in array)
			{
				if (type.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length != 0)
				{
					try
					{
						harmony.CreateClassProcessor(type).Patch();
					}
					catch (Exception arg)
					{
						((BaseUnityPlugin)this).Logger.LogError((object)$"[UsageSkills:Patch] Failed patch class {type.FullName}; its adapter will remain disabled. {arg}");
					}
				}
			}
		}

		private static void RecordHook(string adapter, Type type, string methodName, Type[]? parameterTypes = null)
		{
			MethodInfo methodInfo = ((parameterTypes == null) ? AccessTools.Method(type, methodName, (Type[])null, (Type[])null) : AccessTools.Method(type, methodName, parameterTypes, (Type[])null));
			int num;
			if (methodInfo != null)
			{
				Patches patchInfo = Harmony.GetPatchInfo((MethodBase)methodInfo);
				num = ((patchInfo != null && patchInfo.Owners.Contains("com.chiseled.peak.usageskills")) ? 1 : 0);
			}
			else
			{
				num = 0;
			}
			bool healthy = (byte)num != 0;
			string hook = ((parameterTypes == null) ? (type.FullName + "." + methodName) : (type.FullName + "." + methodName + "(" + string.Join(",", Array.ConvertAll(parameterTypes, (Type value) => value.Name)) + ")"));
			Diagnostics?.RecordPatchHealth(adapter, healthy, hook);
		}
	}
}
namespace PEAKUsageSkills.UI
{
	internal sealed class DebugOverlay : MonoBehaviour
	{
		private GUIStyle? labelStyle;

		private void OnGUI()
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.Settings.EnableMod.Value && Plugin.Settings.ShowDebugOverlay.Value && Plugin.Diagnostics != null)
			{
				if (labelStyle == null)
				{
					labelStyle = new GUIStyle(GUI.skin.label)
					{
						fontSize = 14,
						wordWrap = false,
						richText = false,
						alignment = (TextAnchor)0
					};
					labelStyle.normal.textColor = Color.white;
				}
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(18f, 18f, 820f, 420f);
				GUI.Box(val, GUIContent.none);
				GUILayout.BeginArea(new Rect(((Rect)(ref val)).x + 12f, ((Rect)(ref val)).y + 10f, ((Rect)(ref val)).width - 24f, ((Rect)(ref val)).height - 20f));
				GUILayout.Label(Plugin.Diagnostics.BuildOverlayText(), labelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndArea();
			}
		}
	}
	internal static class PauseMenuIntegration
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__OnLanguageChanged;

			public static BuilderDelegate <1>__BuildPauseMenu;
		}

		private const string RootObjectName = "UI_PEAKUsageSkills_ReleasePanels";

		private const float PanelWidth = 390f;

		private const float HeaderHeight = 56f;

		private const float RowHeight = 32f;

		private static readonly Color MainPanelColor = new Color(0.66f, 0.09f, 0.15f, 1f);

		private static readonly Color ResiliencyPanelColor = new Color(0.08f, 0.3f, 0.68f, 1f);

		private static RectTransform? activeRoot;

		private static readonly SkillId[] MainSkills = new SkillId[10]
		{
			SkillId.Strength,
			SkillId.Endurance,
			SkillId.WallClimbing,
			SkillId.RopeClimbing,
			SkillId.VineClimbing,
			SkillId.Athletics,
			SkillId.Agility,
			SkillId.Vitality,
			SkillId.WetGrip,
			SkillId.ClimbingTenacity
		};

		private static readonly SkillId[] ResiliencySkills = new SkillId[8]
		{
			SkillId.Toxicology,
			SkillId.ColdTolerance,
			SkillId.HeatTolerance,
			SkillId.DrowsyTolerance,
			SkillId.SporeTolerance,
			SkillId.HungerTolerance,
			SkillId.CurseTolerance,
			SkillId.PetrificationResistance
		};

		public static void Register()
		{
			//IL_0030: 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)
			//IL_003b: Expected O, but got Unknown
			LocalizationService.LanguageChanged += OnLanguageChanged;
			object obj = <>O.<1>__BuildPauseMenu;
			if (obj == null)
			{
				BuilderDelegate val = BuildPauseMenu;
				<>O.<1>__BuildPauseMenu = val;
				obj = (object)val;
			}
			MenuAPI.AddToPauseMenu((BuilderDelegate)obj);
		}

		public static void Unregister()
		{
			LocalizationService.LanguageChanged -= OnLanguageChanged;
			activeRoot = null;
		}

		private static void BuildPauseMenu(Transform parent)
		{
			//IL_004b: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_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)
			//IL_00dd: 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)
			RemoveLegacyControls(parent);
			Transform val = parent.Find("UI_PEAKUsageSkills_ReleasePanels");
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			RectTransform component = new GameObject("UI_PEAKUsageSkills_ReleasePanels", new Type[2]
			{
				typeof(RectTransform),
				typeof(SkillPanelRefresher)
			}).GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			activeRoot = component;
			BuildSection(component, "Main", LocalizationService.Get("section.main"), MainSkills, MainPanelColor, new Vector2(24f, -88f), alignRight: false);
			BuildSection(component, "Resiliency", LocalizationService.Get("section.resiliency"), ResiliencySkills, ResiliencyPanelColor, new Vector2(24f, -88f - SectionHeight(MainSkills.Length) - 18f), alignRight: false);
			SkillTooltip.Create(component);
			Refresh(component);
			Plugin.ModLog.LogInfo((object)"[UsageSkills:UI] release skill panels built; values refresh once when the pause UI opens");
		}

		private static void BuildSection(RectTransform root, string sectionName, string title, SkillId[] skills, Color panelColor, Vector2 offset, bool alignRight)
		{
			//IL_004d: 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_0052: 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)
			//IL_0059: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_00c1: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: 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)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			PeakMenuButton val = MenuAPI.CreatePauseMenuButton(title);
			((Object)((Component)val).gameObject).name = "UI_PEAKUsageSkills_Section_" + sectionName;
			RectTransform component = ((Component)val).GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)root, false);
			Vector2 anchorMin = (component.anchorMax = (alignRight ? new Vector2(1f, 1f) : new Vector2(0f, 1f)));
			component.anchorMin = anchorMin;
			component.pivot = (alignRight ? new Vector2(1f, 1f) : new Vector2(0f, 1f));
			component.anchoredPosition = offset;
			component.sizeDelta = new Vector2(390f, SectionHeight(skills.Length));
			LayoutElement component2 = ((Component)val).GetComponent<LayoutElement>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.ignoreLayout = true;
			}
			ConfigurePanelGraphics(val, panelColor);
			Button[] componentsInChildren = ((Component)val).GetComponentsInChildren<Button>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Behaviour)componentsInChildren[i]).enabled = false;
			}
			TextMeshProUGUI[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val3 in componentsInChildren2)
			{
				if (string.Equals(((TMP_Text)val3).text, title, StringComparison.OrdinalIgnoreCase))
				{
					((TMP_Text)val3).rectTransform.anchorMin = new Vector2(0f, 1f);
					((TMP_Text)val3).rectTransform.anchorMax = new Vector2(1f, 1f);
					((TMP_Text)val3).rectTransform.pivot = new Vector2(0.5f, 1f);
					((TMP_Text)val3).rectTransform.anchoredPosition = new Vector2(0f, -8f);
					((TMP_Text)val3).rectTransform.sizeDelta = new Vector2(-20f, 32f);
					((TMP_Text)val3).fontSize = 26f;
					break;
				}
			}
			for (int j = 0; j < skills.Length; j++)
			{
				BuildSkillRow(component, skills[j], j, alignRight);
			}
		}

		private static void BuildSkillRow(RectTransform panel, SkillId skillId, int index, bool openTooltipLeft)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0078: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("UI_PEAKUsageSkills_" + skillId, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(SkillHoverTarget)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)panel, false);
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -56f - (float)index * 32f);
			component.sizeDelta = new Vector2(-24f, 32f);
			((Graphic)val.GetComponent<Image>()).color = new Color(1f, 1f, 1f, 0.001f);
			PeakText obj = MenuAPI.CreateText(string.Empty, "Text");
			((Component)obj).transform.SetParent((Transform)(object)component, false);
			RectTransform component2 = ((Component)obj).GetComponent<RectTransform>();
			obj.SetFontSize(24f);
			Fill(component2, Vector2.zero, Vector2.zero);
			((TMP_Text)obj.TextMesh).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)obj.TextMesh).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)obj.TextMesh).overflowMode = (TextOverflowModes)0;
			((Graphic)obj.TextMesh).raycastTarget = false;
			((TMP_Text)obj.TextMesh).richText = false;
			SkillHoverTarget component3 = val.GetComponent<SkillHoverTarget>();
			component3.Skill = skillId;
			component3.OpenTooltipLeft = openTooltipLeft;
		}

		internal static void Refresh(RectTransform root)
		{
			//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)
			RefreshSectionTitle(root, "Main", "section.main");
			RefreshSectionTitle(root, "Resiliency", "section.resiliency");
			foreach (SkillId value in Enum.GetValues(typeof(SkillId)))
			{
				Transform? obj = FindDeep((Transform)(object)root, "UI_PEAKUsageSkills_" + value);
				object obj2;
				if (obj == null)
				{
					obj2 = null;
				}
				else
				{
					Transform obj3 = obj.Find("Text");
					obj2 = ((obj3 != null) ? ((Component)obj3).GetComponent<PeakText>() : null);
				}
				PeakText val = (PeakText)obj2;
				if ((Object)(object)val != (Object)null)
				{
					val.SetText(GetSkillText(value));
					Fill(((Component)val).GetComponent<RectTransform>(), Vector2.zero, Vector2.zero);
				}
			}
		}

		private static void RefreshSectionTitle(RectTransform root, string sectionName, string localizationKey)
		{
			Transform? obj = FindDeep((Transform)(object)root, "UI_PEAKUsageSkills_Section_" + sectionName);
			PeakMenuButton obj2 = ((obj != null) ? ((Component)obj).GetComponent<PeakMenuButton>() : null);
			if (obj2 != null)
			{
				obj2.SetText(LocalizationService.Get(localizationKey));
			}
		}

		private static void OnLanguageChanged()
		{
			SkillTooltip.Hide();
			if ((Object)(object)activeRoot != (Object)null)
			{
				Refresh(activeRoot);
			}
		}

		internal static string GetTooltipText(SkillId skillId)
		{
			int level = Plugin.Progression.GetLevel(skillId);
			switch (skillId)
			{
			case SkillId.Strength:
			{
				float value = (1f - SkillMath.AnchoredReductionMultiplier(level, Plugin.Settings.StrengthReductionPerLevel.Value)) * 100f;
				return LocalizationService.Get("tooltip.strength", LocalizationService.FormatNumber(value, 1), InventorySkillService.ExtraBackpackSlots);
			}
			case SkillId.Endurance:
				return LocalizationService.Get("tooltip.endurance", LocalizationService.FormatNumber((float)level * 0.5f, 1), LocalizationService.FormatNumber((float)level * 0.1f, 1));
			case SkillId.WallClimbing:
				return ClimbingTooltip(LocalizationService.Get("term.wall"), level, Plugin.Settings.WallSpeedPerLevel.Value, Plugin.Settings.WallCostReductionPerLevel.Value);
			case SkillId.RopeClimbing:
				return ClimbingTooltip(LocalizationService.Get("term.rope"), level, Plugin.Settings.RopeSpeedPerLevel.Value, Plugin.Settings.RopeCostEfficiencyPerLevel.Value);
			case SkillId.VineClimbing:
			{
				float value = (1f - SkillMath.AnchoredReductionMultiplier(level, Plugin.Settings.VineCostEfficiencyPerLevel.Value)) * 100f;
				return LocalizationService.Get("tooltip.vine", LocalizationService.FormatNumber((float)level * 0.3f, 1), LocalizationService.FormatNumber(value, 1));
			}
			case SkillId.Athletics:
			{
				float value = (1f - SkillMath.AnchoredReductionMultiplier(level, Plugin.Settings.AthleticsSprintEfficiencyPerLevel.Value)) * 100f;
				return LocalizationService.Get("tooltip.athletics", LocalizationService.FormatNumber(value, 1));
			}
			case SkillId.Agility:
			{
				float value = (1f - SkillMath.AnchoredReductionMultiplier(level, Plugin.Settings.AgilityJumpEfficiencyPerLevel.Value)) * 100f;
				return LocalizationService.Get("tooltip.agility", LocalizationService.FormatNumber((float)level * 0.15f, 1), LocalizationService.FormatNumber(value, 1));
			}
			case SkillId.Vitality:
				return ReductionTooltip(LocalizationService.Get("term.fall_injury"), level, Plugin.Settings.VitalityFallReductionPerLevel.Value);
			case SkillId.WetGrip:
				return ReductionTooltip(LocalizationService.Get("term.wet_grip_penalty"), level, Plugin.Settings.WetGripReductionPerLevel.Value);
			case SkillId.ClimbingTenacity:
				return ReductionTooltip(LocalizationService.Get("term.tenacity_penalty"), level, Plugin.Settings.ClimbingTenacityReductionPerLevel.Value);
			case SkillId.Toxicology:
			case SkillId.ColdTolerance:
			case SkillId.HeatTolerance:
			case SkillId.DrowsyTolerance:
			case SkillId.SporeTolerance:
				return ToleranceTooltip(LocalizationService.SkillName(skillId), level, hasNaturalRecovery: true);
			case SkillId.HungerTolerance:
			case SkillId.CurseTolerance:
				return ToleranceTooltip(LocalizationService.SkillName(skillId), level, hasNaturalRecovery: false);
			case SkillId.PetrificationResistance:
				return ToleranceTooltip(LocalizationService.SkillName(skillId), level, hasNaturalRecovery: false);
			default:
				return LocalizationService.SkillName(skillId);
			}
		}

		private static string ClimbingTooltip(string kind, int level, float speedRate, float costRate)
		{
			float value = (1f - SkillMath.AnchoredReductionMultiplier(level, costRate)) * 100f;
			return LocalizationService.Get("tooltip.climbing", kind, LocalizationService.FormatNumber(speedRate * 100f, 1), LocalizationService.FormatNumber((float)level * speedRate * 100f, 1), LocalizationService.FormatNumber(value, 1));
		}

		private static string ReductionTooltip(string effect, int level, float rate)
		{
			float value = (1f - SkillMath.AnchoredReductionMultiplier(level, rate)) * 100f;
			return LocalizationService.Get("tooltip.reduction", effect, LocalizationService.FormatNumber(rate * 100f, 2), LocalizationService.FormatNumber(value, 1));
		}

		private static string ToleranceTooltip(string condition, int level, bool hasNaturalRecovery)
		{
			float value = (1f - SkillMath.AnchoredReductionMultiplier(level, Plugin.Settings.ConditionResistancePerLevel.Value)) * 100f;
			string text = (hasNaturalRecovery ? LocalizationService.Get("tooltip.natural_recovery", LocalizationService.FormatNumber((float)level * Plugin.Settings.ConditionRecoveryPerLevel.Value * 100f, 1)) : "");
			return LocalizationService.Get("tooltip.tolerance", condition, LocalizationService.FormatNumber(value, 1), text);
		}

		private static string GetSkillText(SkillId skillId)
		{
			int level = Plugin.Progression.GetLevel(skillId);
			int num = ((level < Plugin.Progression.MaximumLevel) ? SkillMath.ExperienceProgressPercent(Plugin.Progression.GetExperience(skillId), Plugin.Progression.GetExperienceToNextLevel(skillId)) : 0);
			return string.Format("{0} {1} {2:00}.{3:00}", LocalizationService.SkillName(skillId), LocalizationService.Get("level.abbreviation"), level, num);
		}

		private static float SectionHeight(int rowCount)
		{
			return 56f + (float)rowCount * 32f + 16f;
		}

		private static void ConfigurePanelGraphics(PeakMenuButton panel, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			panel.SetColor(color, true);
			Stretch(((Graphic)panel.Panel).rectTransform);
			((Graphic)panel.Panel).raycastTarget = false;
			((Transform)((Graphic)panel.Panel).rectTransform).SetAsFirstSibling();
			ConfigureBorder(((Graphic)panel.BorderTop).rectTransform, top: true);
			ConfigureBorder(((Graphic)panel.BorderBottom).rectTransform, top: false);
			((Graphic)panel.BorderTop).raycastTarget = false;
			((Graphic)panel.BorderBottom).raycastTarget = false;
		}

		private static void Stretch(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.anchoredPosition = Vector2.zero;
			rect.sizeDelta = Vector2.zero;
		}

		private static void Fill(RectTransform rect, Vector2 minimumInset, Vector2 maximumInset)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.offsetMin = minimumInset;
			rect.offsetMax = maximumInset;
		}

		private static void ConfigureBorder(RectTransform border, bool top)
		{
			//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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = border.rect;
			float num = Mathf.Max(3f, ((Rect)(ref rect)).height);
			border.anchorMin = new Vector2(0f, top ? 1f : 0f);
			border.anchorMax = new Vector2(1f, top ? 1f : 0f);
			border.pivot = new Vector2(0.5f, top ? 1f : 0f);
			border.anchoredPosition = Vector2.zero;
			border.sizeDelta = new Vector2(0f, num);
		}

		internal static string WrapTooltipText(string message, int maximumLineLength = 58)
		{
			if (ContainsCjk(message))
			{
				int num = Math.Max(32, maximumLineLength - 14);
				StringBuilder stringBuilder = new StringBuilder(message.Length + 8);
				int num2 = 0;
				foreach (char c in message)
				{
					if (c == '\n')
					{
						stringBuilder.Append(c);
						num2 = 0;
						continue;
					}
					int num3 = ((!IsCjk(c)) ? 1 : 2);
					if (num2 > 0 && num2 + num3 > num)
					{
						stringBuilder.Append('\n');
						num2 = 0;
						if (char.IsWhiteSpace(c))
						{
							continue;
						}
					}
					stringBuilder.Append(c);
					num2 += num3;
				}
				return stringBuilder.ToString();
			}
			string[] array = message.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			StringBuilder stringBuilder2 = new StringBuilder(message.Length + 8);
			int num4 = 0;
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (num4 > 0 && num4 + 1 + text.Length > maximumLineLength)
				{
					stringBuilder2.Append('\n');
					num4 = 0;
				}
				if (num4 > 0)
				{
					stringBuilder2.Append(' ');
					num4++;
				}
				stringBuilder2.Append(text);
				num4 += text.Length;
			}
			return stringBuilder2.ToString();
		}

		private static bool ContainsCjk(string value)
		{
			for (int i = 0; i < value.Length; i++)
			{
				if (IsCjk(value[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsCjk(char character)
		{
			if ((character < '\u3040' || character > 'ヿ') && (character < '㐀' || character > '鿿'))
			{
				if (character >= '가')
				{
					return character <= '\ud7af';
				}
				return false;
			}
			return true;
		}

		private static void RemoveLegacyControls(Transform parent)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			string[] array = new string[3] { "UI_MainMenuButton_PEAKUsageSkills", "UI_MainMenuButton_PEAKUsageSkillsTestLevel", "UI_MainMenuButton_PEAKUsageSkillsReset" };
			foreach (string text in array)
			{
				Transform val = parent.Find(text);
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			List<GameObject> list = new List<GameObject>();
			foreach (Transform item in parent)
			{
				Transform val2 = item;
				if (((Object)val2).name.StartsWith("UI_MainMenuButton_PEAKUsageSkillsStatus_", StringComparison.Ordinal))
				{
					list.Add(((Component)val2).gameObject);
				}
			}
			foreach (GameObject item2 in list)
			{
				Object.Destroy((Object)(object)item2);
			}
		}

		private static Transform? FindDeep(Transform root, string objectName)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			foreach (Transform item in root)
			{
				Transform val = item;
				if (((Object)val).name == objectName)
				{
					return val;
				}
				Transform val2 = FindDeep(val, objectName);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return null;
		}
	}
	internal sealed class SkillPanelRefresher : MonoBehaviour
	{
		private void OnEnable()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			PauseMenuIntegration.Refresh((RectTransform)((Component)this).transform);
		}
	}
	internal sealed class SkillHoverTarget : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public SkillId Skill { get; set; }

		public bool OpenTooltipLeft { get; set; }

		public void OnPointerEnter(PointerEventData eventData)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			SkillTooltip.Show((RectTransform)((Component)this).transform, PauseMenuIntegration.GetTooltipText(Skill), OpenTooltipLeft);
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			SkillTooltip.Hide();
		}
	}
	internal sealed class SkillTooltip : MonoBehaviour
	{
		private static SkillTooltip? instance;

		private RectTransform rect;

		private PeakText text;

		public static void Create(RectTransform parent)
		{
			//IL_0032: 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_0059: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("UI_PEAKUsageSkills_Tooltip", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(SkillTooltip)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)parent, false);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.pivot = new Vector2(0f, 0.5f);
			component.sizeDelta = new Vector2(500f, 124f);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.035f, 0.035f, 0.04f, 0.94f);
			PeakText val3 = MenuAPI.CreateText(string.Empty, "Text");
			((Component)val3).transform.SetParent((Transform)(object)component, false);
			RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
			val3.SetFontSize(21f);
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(12f, 8f);
			component2.offsetMax = new Vector2(-12f, -8f);
			((TMP_Text)val3.TextMesh).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)val3.TextMesh).textWrappingMode = (TextWrappingModes)1;
			((TMP_Text)val3.TextMesh).overflowMode = (TextOverflowModes)3;
			((Graphic)val3.TextMesh).raycastTarget = false;
			SkillTooltip component3 = val.GetComponent<SkillTooltip>();
			component3.rect = component;
			component3.text = val3;
			instance = component3;
			val.SetActive(false);
		}

		public static void Show(RectTransform target, string message, bool openLeft)
		{
			//IL_0046: 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)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)instance == (Object)null))
			{
				((Component)instance).gameObject.SetActive(true);
				instance.text.SetText(PauseMenuIntegration.WrapTooltipText(message));
				RectTransform component = ((Component)instance.text).GetComponent<RectTransform>();
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.one;
				component.offsetMin = new Vector2(12f, 8f);
				component.offsetMax = new Vector2(-12f, -8f);
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				target.GetWorldCorners(array);
				instance.rect.pivot = new Vector2(openLeft ? 1f : 0f, 0.5f);
				((Transform)instance.rect).position = (openLeft ? array[1] : array[2]) + Vector3.right * (openLeft ? (-16f) : 16f);
				((Transform)instance.rect).SetAsLastSibling();
			}
		}

		public static void Hide()
		{
			if ((Object)(object)instance != (Object)null)
			{
				((Component)instance).gameObject.SetActive(false);
			}
		}
	}
}
namespace PEAKUsageSkills.Tracking
{
	internal sealed class ActivitySampler : MonoBehaviour
	{
		private const float SampleInterval = 0.2f;

		private Character? sampledCharacter;

		private Vector3 lastPosition;

		private float lastSampleTime;

		private bool hasPosition;

		private void Update()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledTime - lastSampleTime < 0.2f)
			{
				return;
			}
			lastSampleTime = Time.unscaledTime;
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || !Plugin.RunState.IsGameplayScene)
			{
				ResetSample(localCharacter);
				return;
			}
			Vector3 center = localCharacter.Center;
			if ((Object)(object)sampledCharacter != (Object)(object)localCharacter || !hasPosition)
			{
				sampledCharacter = localCharacter;
				lastPosition = center;
				hasPosition = true;
				return;
			}
			Vector3 val = center - lastPosition;
			lastPosition = center;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (Plugin.Diagnostics != null)
			{
				Plugin.Diagnostics.Metrics.LastPhysicalMovementDistance = magnitude;
			}
			if (magnitude > 5f)
			{
				Plugin.Diagnostics?.RecordRejected(SkillId.Strength, "TeleportDelta", magnitude);
				Plugin.Diagnostics?.RecordRejected(SkillId.WallClimbing, "TeleportDelta", magnitude);
				Plugin.Diagnostics?.RecordRejected(SkillId.RopeClimbing, "TeleportDelta", magnitude);
				Plugin.Diagnostics?.RecordRejected(SkillId.VineClimbing, "TeleportDelta", magnitude);
				Plugin.Diagnostics?.RecordRejected(SkillId.Athletics, "TeleportDelta", magnitude);
				Plugin.Diagnostics?.RecordRejected(SkillId.WetGrip, "TeleportDelta", magnitude);
				Plugin.Diagnostics?.RecordRejected(SkillId.ClimbingTenacity, "TeleportDelta", magnitude);
				Plugin.Diagnostics?.RecordRejected(SkillId.HungerTolerance, "TeleportDelta", magnitude);
				return;
			}
			if (magnitude >= 0.01f)
			{
				float num = Plugin.Diagnostics?.Metrics.RawWeight ?? 0f;
				if (num >= 0.025f)
				{
					double work = num * magnitude;
					Plugin.Progression.AwardWork(SkillId.Strength, work, Plugin.Settings.StrengthXpPerWork.Value, localCharacter.data.isClimbingAnything ? "WeightedClimbing" : "WeightedMovement");
				}
				CharacterRefs refs = localCharacter.refs;
				float? obj;
				if (refs == null)
				{
					obj = null;
				}
				else
				{
					CharacterAfflictions afflictions = refs.afflictions;
					obj = ((afflictions != null) ? new float?(afflictions.GetCurrentStatus((STATUSTYPE)1)) : ((float?)null));
				}
				float? num2 = obj;
				double num3 = SkillMath.HungerMovementWork(num2.GetValueOrDefault(), magnitude, Plugin.Settings.HungerTrainingThreshold.Value);
				if (num3 > 0.0)
				{
					Plugin.Progression.AwardWork(SkillId.HungerTolerance, num3, Plugin.Settings.HungerMovementXpPerWork.Value, "HungryMovement");
				}
			}
			bool num4 = localCharacter.data.isClimbing && !localCharacter.data.isRopeClimbing && !localCharacter.data.isVineClimbing;
			bool flag = (Object)(object)localCharacter.input != (Object)null && ((Vector2)(ref localCharacter.input.movementInput)).sqrMagnitude >= 0.01f;
			float num5 = ((num4 && flag) ? magnitude : 0f);
			float num6 = ((localCharacter.data.isRopeClimbing && flag) ? magnitude : 0f);
			float num7 = ((localCharacter.data.isVineClimbing && flag) ? magnitude : 0f);
			if (Plugin.Diagnostics != null)
			{
				Plugin.Diagnostics.Metrics.LastWallVerticalDelta = num5;
				Plugin.Diagnostics.Metrics.LastRopeVerticalDelta = num6;
				Plugin.Diagnostics.Metrics.LastVineVerticalDelta = num7;
			}
			if (num5 >= 0.005f)
			{
				if (Plugin.Diagnostics != null)
				{
					Plugin.Diagnostics.Metrics.SessionWallVerticalDistance += num5;
				}
				Plugin.Progression.AwardWork(SkillId.WallClimbing, num5, Plugin.Settings.WallClimbingXpPerMeter.Value, "IntentionalWallDistance");
				float num8 = Mathf.Clamp01(localCharacter.data.slippy);
				if (num8 > 0.001f)
				{
					Plugin.Progression.AwardWork(SkillId.WetGrip, num5 * num8, Plugin.Settings.WetGripXpPerMeter.Value, "SlipperyWallDistance");
				}
				if (localCharacter.GetTotalStamina() < 0.2f)
				{
					Plugin.Progression.AwardWork(SkillId.ClimbingTenacity, num5, Plugin.Settings.ClimbingTenacityXpPerMeter.Value, "LowStaminaWallDistance");
				}
			}
			if (num6 >= 0.005f)
			{
				Plugin.Progression.AwardWork(SkillId.RopeClimbing, num6, Plugin.Settings.RopeClimbingXpPerMeter.Value, "IntentionalRopeDistance");
			}
			if (num7 >= 0.005f)
			{
				Plugin.Progression.AwardWork(SkillId.VineClimbing, num7, Plugin.Settings.VineClimbingXpPerMeter.Value, "IntentionalVineDistance");
			}
			Vector2 val2 = new Vector2(val.x, val.z);
			float magnitude2 = ((Vector2)(ref val2)).magnitude;
			if (localCharacter.data.isGrounded && !localCharacter.data.isClimbingAnything && (Object)(object)localCharacter.input != (Object)null && ((Vector2)(ref localCharacter.input.movementInput)).sqrMagnitude >= 0.01f && magnitude2 >= 0.01f)
			{
				Plugin.Progression.AwardWork(SkillId.Athletics, magnitude2, localCharacter.data.isSprinting ? Plugin.Settings.AthleticsSprintXpPerMeter.Value : Plugin.Settings.AthleticsXpPerMeter.Value, localCharacter.data.isSprinting ? "GroundSprinting" : "GroundMovement");
			}
		}

		private void ResetSample(Character? character)
		{
			sampledCharacter = character;
			hasPosition = false;
			if (Plugin.Diagnostics != null)
			{
				Plugin.Diagnostics.Metrics.LastWallVerticalDelta = 0f;
				Plugin.Diagnostics.Metrics.LastRopeVerticalDelta = 0f;
				Plugin.Diagnostics.Metrics.LastVineVerticalDelta = 0f;
			}
		}
	}
}
namespace PEAKUsageSkills.Persistence
{
	internal sealed class ProgressionSave
	{
		public int SchemaVersion { get; set; } = 1;

		public DateTime LastSavedUtc { get; set; } = DateTime.UtcNow;

		public Dictionary<string, SkillSave> Skills { get; set; } = new Dictionary<string, SkillSave>(StringComparer.Ordinal);
	}
	internal sealed class SkillSave
	{
		public int Level { get; set; } = 1;

		public double Experience { get; set; }

		public double LifetimeWork { get; set; }
	}
	internal sealed class SaveStore
	{
		private const int MaximumBackups = 5;

		private readonly ManualLogSource log;

		private readonly string saveDirectory;

		private readonly string savePath;

		private readonly string backupDirectory;

		public SaveStore(ManualLogSource log)
		{
			this.log = log;
			saveDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "LandCrab", "PEAK", "PEAKUsageSkills");
			savePath = Path.Combine(saveDirectory, "progression.json");
			backupDirectory = Path.Combine(saveDirectory, "backups");
		}

		public ProgressionSave Load()
		{
			Directory.CreateDirectory(saveDirectory);
			Directory.CreateDirectory(backupDirectory);
			if (TryLoad(savePath, out ProgressionSave save))
			{
				log.LogInfo((object)("Loaded usage-skill progression from " + savePath));
				return save;
			}
			foreach (string item in GetBackupsNewestFirst())
			{
				if (TryLoad(item, out save))
				{
					log.LogWarning((object)("Recovered usage-skill progression from backup " + item));
					return save;
				}
			}
			log.LogInfo((object)"No valid usage-skill save found; starting new progression.");
			return new ProgressionSave();
		}

		public void Save(ProgressionSave save)
		{
			Directory.CreateDirectory(saveDirectory);
			Directory.CreateDirectory(backupDirectory);
			save.LastSavedUtc = DateTime.UtcNow;
			string text = savePath + ".tmp";
			string contents = JsonConvert.SerializeObject((object)save, (Formatting)1);
			File.WriteAllText(text, contents);
			if (File.Exists(savePath))
			{
				string destinationBackupFileName = Path.Combine(backupDirectory, $"progression-{DateTime.UtcNow:yyyyMMdd-HHmmss-fff}.json");
				File.Replace(text, savePath, destinationBackupFileName, ignoreMetadataErrors: true);
			}
			else
			{
				File.Move(text, savePath);
			}
			CleanupBackups();
		}

		private bool TryLoad(string path, out ProgressionSave? save)
		{
			save = null;
			if (!File.Exists(path))
			{
				return false;
			}
			try
			{
				save = JsonConvert.DeserializeObject<ProgressionSave>(File.ReadAllText(path));
				return save != null && save.SchemaVersion == 1 && save.Skills != null;
			}
			catch (Exception ex)
			{
				log.LogWarning((object)("Could not load progression file " + path + ": " + ex.Message));
				return false;
			}
		}

		private IEnumerable<string> GetBackupsNewestFirst()
		{
			if (!Directory.Exists(backupDirectory))
			{
				return Array.Empty<string>();
			}
			return Directory.GetFiles(backupDirectory, "progression-*.json").OrderByDescending(File.GetLastWriteTimeUtc);
		}

		private void CleanupBackups()
		{
			string[] array = GetBackupsNewestFirst().ToArray();
			for (int i = 5; i < array.Length; i++)
			{
				try
				{
					File.Delete(array[i]);
				}
				catch (Exception ex)
				{
					log.LogWarning((object)("Could not remove old progression backup " + array[i] + ": " + ex.Message));
				}
			}
		}
	}
}
namespace PEAKUsageSkills.Localization
{
	internal static class LocalizationService
	{
		private sealed class LocaleDefinition
		{
			public string FileName { get; }

			public Language[] Languages { get; }

			public LocaleDefinition(string fileName, params Language[] languages)
			{
				FileName = fileName;
				Languages = languages;
			}
		}

		private const string TranslationIndexPrefix = "ELINS_PEAK_";

		private static readonly Dictionary<string, string> English = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "section.main", "MAIN SKILLS" },
			{ "section.resiliency", "RESILIENCY" },
			{ "level.abbreviation", "Lv." },
			{ "skill.strength", "Strength" },
			{ "skill.endurance", "Endurance" },
			{ "skill.wall_climbing", "Wall Climbing" },
			{ "skill.rope_climbing", "Rope Climbing" },
			{ "skill.vine_climbing", "Vine Climbing" },
			{ "skill.athletics", "Athletics" },
			{ "skill.agility", "Agility" },
			{ "skill.vitality", "Vitality" },
			{ "skill.wet_grip", "Wet Grip" },
			{ "skill.climbing_tenacity", "Climbing Tenacity" },
			{ "skill.poison", "Poison" },
			{ "skill.cold", "Cold" },
			{ "skill.heat", "Heat" },
			{ "skill.drowsy", "Drowsy" },
			{ "skill.spores", "Spores" },
			{ "skill.hunger", "Hunger" },
			{ "skill.curse", "Curse" },
			{ "skill.petrification", "Petrification" },
			{ "term.wall", "wall" },
			{ "term.rope", "rope" },
			{ "term.vine", "vine" },
			{ "term.fall_injury", "fall Injury" },
			{ "term.wet_grip_penalty", "rain/slippery climbing pull and wind stamina drain" },
			{ "term.tenacity_penalty", "climbing control, slide, and stamina penalties below 20% stamina" },
			{ "tooltip.strength", "Reduces carried Weight and adds item slots to Backpacks, Fanny Packs, and Jet Packs at levels 20/40/70/120/200. Current: {0}% less Weight, +{1} slots." },
			{ "tooltip.endurance", "Adds 0.5% base stamina and 0.1% regeneration per level. Current: +{0} stamina, +{1}% regeneration." },
			{ "tooltip.vine", "Improves vine speed by 0.3% per level, reduces stamina cost, and retains light slide momentum. Current: +{0}% speed, {1}% less cost." },
			{ "tooltip.athletics", "Improves ground force by 0.1% and sprint force by another 0.2% per level. Current sprint cost reduction: {0}%." },
			{ "tooltip.agility", "Improves jump impulse and very lightly improves air control. Current: +{0}% jump impulse, {1}% less jump cost." },
			{ "tooltip.climbing", "Improves {0} climbing speed by {1}% per level and reduces stamina cost. Current: +{2}% speed, {3}% less cost." },
			{ "tooltip.reduction", "Reduces {0} using the {1}% anchored curve. Current bonus: {2}% reduction." },
			{ "tooltip.tolerance", "Reduces incoming {0}. Current reduction: {1}%.{2} XP comes only from receiving the affliction." },
			{ "tooltip.natural_recovery", " Natural recovery: +{0}%." }
		};

		private static readonly Dictionary<SkillId, string> SkillKeys = new Dictionary<SkillId, string>
		{
			{
				SkillId.Strength,
				"skill.strength"
			},
			{
				SkillId.Endurance,
				"skill.endurance"
			},
			{
				SkillId.WallClimbing,
				"skill.wall_climbing"
			},
			{
				SkillId.RopeClimbing,
				"skill.rope_climbing"
			},
			{
				SkillId.VineClimbing,
				"skill.vine_climbing"
			},
			{
				SkillId.Athletics,
				"skill.athletics"
			},
			{
				SkillId.Agility,
				"skill.agility"
			},
			{
				SkillId.Vitality,
				"skill.vitality"
			},
			{
				SkillId.WetGrip,
				"skill.wet_grip"
			},
			{
				SkillId.ClimbingTenacity,
				"skill.climbing_tenacity"
			},
			{
				SkillId.Toxicology,
				"skill.poison"
			},
			{
				SkillId.ColdTolerance,
				"skill.cold"
			},
			{
				SkillId.HeatTolerance,
				"skill.heat"
			},
			{
				SkillId.DrowsyTolerance,
				"skill.drowsy"
			},
			{
				SkillId.SporeTolerance,
				"skill.spores"
			},
			{
				SkillId.HungerTolerance,
				"skill.hunger"
			},
			{
				SkillId.CurseTolerance,
				"skill.curse"
			},
			{
				SkillId.PetrificationResistance,
				"skill.petrification"
			}
		};

		private static readonly LocaleDefinition[] Locales = new LocaleDefinition[6]
		{
			new LocaleDefinition("fr.json", (Language)1),
			new LocaleDefinition("de.json", (Language)3),
			new LocaleDefinition("es.json", (Language)4, (Language)5),
			new LocaleDefinition("zh-CN.json", (Language)9),
			new LocaleDefinition("ja.json", (Language)11),
			new LocaleDefinition("ko.json", (Language)12)
		};

		private static bool initialized;

		private static bool nativeRegistrationAvailable;

		public static string Locale => GetLocaleCode(LocalizedText.CURRENT_LANGUAGE);

		public static event Action? LanguageChanged;

		public static void Initialize(string pluginDirectory)
		{
			if (initialized)
			{
				Shutdown();
			}
			try
			{
				RegisterEnglish();
				string localizationDirectory = Path.Combine(pluginDirectory, "Localization");
				LocaleDefinition[] locales = Locales;
				foreach (LocaleDefinition locale in locales)
				{
					LoadAndRegister(localizationDirectory, locale);
				}
				LocalizedText.OnLangugageChanged = (Action)Delegate.Combine(LocalizedText.OnLangugageChanged, new Action(OnGameLanguageChanged));
				nativeRegistrationAvailable = true;
				initialized = true;
				Plugin.ModLog.LogInfo((object)$"[UsageSkills:Localization] registered={English.Count} locale={Locale} source=PEAK selector");
			}
			catch (Exception ex)
			{
				nativeRegistrationAvailable = false;
				initialized = false;
				Plugin.ModLog.LogWarning((object)("[UsageSkills:Localization] PEAK localization registration failed; using English. " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		public static void Shutdown()
		{
			if (initialized)
			{
				LocalizedText.OnLangugageChanged = (Action)Delegate.Remove(LocalizedText.OnLangugageChanged, new Action(OnGameLanguageChanged));
				LocalizationService.LanguageChanged = null;
				nativeRegistrationAvailable = false;
				initialized = false;
			}
		}

		public static string Get(string key, params object[] args)
		{
			string value = "";
			if (nativeRegistrationAvailable)
			{
				try
				{
					value = LocalizedText.GetText(GetTranslationIndex(key), false);
				}
				catch (Exception ex)
				{
					Plugin.ModLog.LogWarning((object)("[UsageSkills:Localization] lookup failed key=" + key + "; using English. " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			if (string.IsNullOrEmpty(value) && !English.TryGetValue(key, out value))
			{
				value = key;
			}
			if (args == null || args.Length == 0)
			{
				return value;
			}
			try
			{
				return string.Format(GetFormattingCulture(), value, args);
			}
			catch (FormatException ex2)
			{
				Plugin.ModLog.LogWarning((object)("[UsageSkills:Localization] invalid format key=" + key + " locale=" + Locale + "; using English. " + ex2.Message));
				string value2;
				return English.TryGetValue(key, out value2) ? string.Format(GetFormattingCulture(), value2, args) : value;
			}
		}

		public static string FormatNumber(float value, int decimalPlaces)
		{
			return value.ToString("F" + decimalPlaces, GetFormattingCulture());
		}

		public static string SkillName(SkillId skillId)
		{
			if (!SkillKeys.TryGetValue(skillId, out string value))
			{
				return skillId.ToString();
			}
			return Get(value);
		}

		private static void RegisterEnglish()
		{
			foreach (KeyValuePair<string, string> item in English)
			{
				MenuAPI.CreateLocalization(GetTranslationIndex(item.Key)).AddLocalization(item.Value, (Language)0);
			}
		}

		private static void LoadAndRegister(string localizationDirectory, LocaleDefinition locale)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			string path = Path.Combine(localizationDirectory, locale.FileName);
			try
			{
				if (!File.Exists(path))
				{
					Plugin.ModLog.LogWarning((object)("[UsageSkills:Localization] missing=" + locale.FileName + "; affected languages use English"));
					return;
				}
				Dictionary<string, string> dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(File.ReadAllText(path));
				if (dictionary == null || dictionary.Count == 0)
				{
					Plugin.ModLog.LogWarning((object)("[UsageSkills:Localization] empty=" + locale.FileName + "; affected languages use English"));
					return;
				}
				int num = 0;
				int num2 = 0;
				foreach (string key in English.Keys)
				{
					if (!dictionary.TryGetValue(key, out var value) || string.IsNullOrWhiteSpace(value))
					{
						num2++;
						continue;
					}
					Language[] languages = locale.Languages;
					foreach (Language val in languages)
					{
						MenuAPI.CreateLocalization(GetTranslationIndex(key)).AddLocalization(value, val);
					}
					num++;
				}
				Plugin.ModLog.LogInfo((object)$"[UsageSkills:Localization] file={locale.FileName} registered={num} missing={num2}");
			}
			catch (Exception ex)
			{
				Plugin.ModLog.LogWarning((object)("[UsageSkills:Localization] failed=" + locale.FileName + "; affected languages use English. " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static void OnGameLanguageChanged()
		{
			Plugin.ModLog.LogInfo((object)("[UsageSkills:Localization] changed locale=" + Locale));
			try
			{
				LocalizationService.LanguageChanged?.Invoke();
			}
			catch (Exception ex)
			{
				Plugin.ModLog.LogWarning((object)("[UsageSkills:Localization] UI refresh failed after language change. " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static string GetTranslationIndex(string key)
		{
			return "ELINS_PEAK_" + key.Replace('.', '_').ToUpperInvariant();
		}

		private static CultureInfo GetFormattingCulture()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected I4, but got Unknown
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			return (cURRENT_LANGUAGE - 1) switch
			{
				0 => CultureInfo.GetCultureInfo("fr-FR"), 
				2 => CultureInfo.GetCultureInfo("de-DE"), 
				4 => CultureInfo.GetCultureInfo("es-MX"), 
				3 => CultureInfo.GetCultureInfo("es-ES"), 
				8 => CultureInfo.GetCultureInfo("zh-CN"), 
				10 => CultureInfo.GetCultureInfo("ja-JP"), 
				11 => CultureInfo.GetCultureInfo("ko-KR"), 
				_ => CultureInfo.GetCultureInfo("en-US"), 
			};
		}

		private static string GetLocaleCode(Language language)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected I4, but got Unknown
			return (language - 1) switch
			{
				0 => "fr", 
				1 => "it", 
				2 => "de", 
				3 => "es-ES", 
				4 => "es-419", 
				5 => "pt-BR", 
				6 => "ru", 
				7 => "uk", 
				8 => "zh-CN", 
				9 => "zh-TW", 
				10 => "ja", 
				11 => "ko", 
				12 => "pl", 
				13 => "tr", 
				_ => "en", 
			};
		}
	}
}
namespace PEAKUsageSkills.GameAdapters
{
	internal static class ConditionSkillAdapter
	{
		public static bool TryGetToleranceSkill(STATUSTYPE statusType, out SkillId skillId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected I4, but got Unknown
			switch (statusType - 1)
			{
			case 2:
				skillId = SkillId.Toxicology;
				return true;
			case 1:
				skillId = SkillId.ColdTolerance;
				return true;
			case 7:
				skillId = SkillId.HeatTolerance;
				return true;
			case 5:
				skillId = SkillId.DrowsyTolerance;
				return true;
			case 9:
				skillId = SkillId.SporeTolerance;
				return true;
			case 0:
				skillId = SkillId.HungerTolerance;
				return true;
			case 4:
				skillId = SkillId.CurseTolerance;
				return true;
			case 12:
				skillId = SkillId.PetrificationResistance;
				return true;
			default:
				skillId = SkillId.Strength;
				return false;
			}
		}

		public static bool TryGetRecoveryTolerance(STATUSTYPE statusType, out SkillId skillId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected I4, but got Unknown
			switch (statusType - 2)
			{
			case 1:
				skillId = SkillId.Toxicology;
				return true;
			case 0:
				skillId = SkillId.ColdTolerance;
				return true;
			case 6:
				skillId = SkillId.HeatTolerance;
				return true;
			case 4:
				skillId = SkillId.DrowsyTolerance;
				return true;
			case 8:
				skillId = SkillId.SporeTolerance;
				return true;
			default:
				skillId = SkillId.Strength;
				return false;
			}
		}
	}
	internal static class InventorySkillService
	{
		private static Character? cachedBackpackCharacter;

		private static ItemInstanceData? cachedBackpackInstance;

		private static BackpackData? cachedBackpackData;

		public static int ExtraBackpackSlots => SkillMath.ExtraBackpackSlots(Plugin.Progression.GetLevel(SkillId.Strength));

		public static bool IsItemStorage(BackpackType backpackType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if ((int)backpackType != 1 && (int)backpackType != 2)
			{
				return (int)backpackType == 3;
			}
			return true;
		}

		public static int BaseItemSlots(BackpackType backpackType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected I4, but got Unknown
			return (backpackType - 1) switch
			{
				0 => 4, 
				1 => 2, 
				2 => 1, 
				_ => 0, 
			};
		}

		public static int DesiredItemCapacity(BackpackType backpackType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			int num = BaseItemSlots(backpackType);
			if (num != 0)
			{
				return num + ExtraBackpackSlots;
			}
			return 0;
		}

		public static int EnsureBackpackCapacity(BackpackData? data, BackpackType backpackType, string source)
		{
			//IL_0003: 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_0050: 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_00a0: Expected O, but got Unknown
			if (data == null || !IsItemStorage(backpackType))
			{
				return 0;
			}
			ItemSlot[] array = data.itemSlots ?? Array.Empty<ItemSlot>();
			int num = Math.Max(DesiredItemCapacity(backpackType), HighestOccupiedIndex(array) + 1);
			if (array.Length < num)
			{
				Array.Resize(ref array, num);
				data.itemSlots = array;
				Plugin.ModLog.LogInfo((object)($"[UsageSkills:Inventory] {backpackType} item slots expanded to {num} " + $"strength={Plugin.Progression.GetLevel(SkillId.Strength)} source={source}"));
			}
			for (int i = 0; i < array.Length; i++)
			{
				ItemSlot[] array2 = array;
				int num2 = i;
				if (array2[num2] == null)
				{
					array2[num2] = new ItemSlot((byte)i);
				}
			}
			return num;
		}

		public static BackpackData? TryGetEquippedBackpackData(Character? character, out BackpackType backpackType)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected I4, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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)
			backpackType = (BackpackType)(int)((character == null) ? ((BackpackType?)null) : character.player?.backpackSlot?.backpackType).GetValueOrDefault();
			if (((character == null) ? null : character.player?.backpackSlot) == null || ((ItemSlot)character.player.backpackSlot).IsEmpty())
			{
				cachedBackpackCharacter = character;
				cachedBackpackInstance = null;
				cachedBackpackData = null;
				return null;
			}
			if (!IsItemStorage(backpackType))
			{
				cachedBackpackCharacter = character;
				cachedBackpackInstance = ((ItemSlot)character.player.backpackSlot).data;
				cachedBackpackData = null;
				return null;
			}
			ItemInstanceData data = ((ItemSlot)character.player.backpackSlot).data;
			if ((Object)(object)character == (Object)(object)cachedBackpackCharacter && data == cachedBackpackInstance)
			{
				return cachedBackpackData;
			}
			try
			{
				BackpackReference fromEquippedBackpack = BackpackReference.GetFromEquippedBackpack(character);
				cachedBackpackCharacter = character;
				cachedBackpackInstance = data;
				cachedBackpackData = (((BackpackReference)(ref fromEquippedBackpack)).exists ? ((BackpackReference)(ref fromEquippedBackpack)).GetData() : null);
				return cachedBackpackData;
			}
			catch (Exception ex)
			{
				Plugin.ModLog.LogWarning((object)("[UsageSkills:Inventory] backpack lookup failed: " + ex.Message));
				return null;
			}
		}

		private static int HighestOccupiedIndex(ItemSlot[] slots)
		{
			for (int num = slots.Length - 1; num >= 0; num--)
			{
				if (slots[num] != null && !slots[num].IsEmpty())
				{
					return num;
				}
			}
			return -1;
		}
	}
	internal sealed class InventorySkillController : MonoBehaviour
	{
		private BackpackData? lastBackpackData;

		private int lastDesiredCapacity;

		private BackpackType lastBackpackType;

		private void Update()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			BackpackType backpackType;
			BackpackData val = InventorySkillService.TryGetEquippedBackpackData(Character.localCharacter, out backpackType);
			int num = InventorySkillService.DesiredItemCapacity(backpackType);
			if (val != null && (val != lastBackpackData || backpackType != lastBackpackType || num != lastDesiredCapacity || val.itemSlots.Length < num))
			{
				InventorySkillService.EnsureBackpackCapacity(val, backpackType, "Controller");
				lastBackpackData = val;
				lastBackpackType = backpackType;
				lastDesiredCapacity = num;
			}
		}
	}
	internal sealed class RunStateAdapter
	{
		private readonly UsageSkillsConfig config;

		public string ActiveSceneName
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Scene activeScene = SceneManager.GetActiveScene();
				return ((Scene)(ref activeScene)).name ?? string.Empty;
			}
		}

		public bool IsAirport => ActiveSceneName.IndexOf("airport", StringComparison.OrdinalIgnoreCase) >= 0;

		public bool IsGameplayScene
		{
			get
			{
				if (!IsAirport)
				{
					return (Object)(object)Character.localCharacter != (Object)null;
				}
				return false;
			}
		}

		public bool IsExperienceEligible
		{
			get
			{
				if (!config.EnableMod.Value || !config.EnableExperience.Value || !IsGameplayScene || (Object)(object)Character.localCharacter == (Object)null)
				{
					return false;
				}
				if (!config.EnableXpInCustomRuns.Value)
				{
					return !RunSettings.IsCustomRun;
				}
				return true;
			}
		}

		public RunStateAdapter(UsageSkillsConfig config)
		{
			this.config = config;
		}
	}
}
namespace PEAKUsageSkills.GameAdapters.Patches
{
	[HarmonyPatch(typeof(CharacterClimbing), "GetRequestedPostition")]
	internal static class WallClimbingSpeedPatch
	{
		private struct State
		{
			public bool Applied;

			public float Original;

			public float OriginalSlippy;
		}

		private static void Prefix(CharacterClimbing __instance, Character ___character, out State __state)
		{
			__state = new State
			{
				Applied = false,
				Original = __instance.climbSpeedMod,
				OriginalSlippy = (___character?.data.slippy ?? 0f)
			};
			if (!((Object)(object)___character == (Object)null) && Plugin.Effects.CanApply(___character) && !___character.data.isRopeClimbing && !___character.data.isVineClimbing)
			{
				__instance.climbSpeedMod = __state.Original * Plugin.Effects.WallSpeedMultiplier;
				___character.data.slippy = __state.OriginalSlippy * Plugin.Effects.WetGripPenaltyMultiplier;
				__state.Applied = true;
			}
		}

		private static void Postfix(CharacterClimbing __instance, State __state)
		{
			Restore(__instance, __state);
		}

		private static Exception? Finalizer(CharacterClimbing __instance, State __state, Exception? __exception)
		{
			Restore(__instance, __state);
			return __exception;
		}

		private static void Restore(CharacterClimbing instance, State state)
		{
			if (state.Applied)
			{
				instance.climbSpeedMod = state.Original;
				object? value = AccessTools.Field(typeof(CharacterClimbing), "character").GetValue(instance);
				Character val = (Character)((value is Character) ? value : null);
				if ((Object)(object)val != (Object)null)
				{
					val.data.slippy = state.OriginalSlippy;
				}
			}
		}
	}
	[HarmonyPatch(typeof(CharacterRopeHandling), "Update")]
	internal static class RopeClimbingSpeedPatch
	{
		private struct State
		{
			public bool Applied;

			public float Original;
		}

		private static void Prefix(CharacterRopeHandling __instance, Character ___character, out State __state)
		{
			__state = new State
			{
				Applied = false,
				Original = __instance.climbSpeedMod
			};
			if (!((Object)(object)___character == (Object)null) && ___character.data.isRopeClimbing && Plugin.Effects.CanApply(___character))
			{
				__instance.climbSpeedMod = __state.Original * Plugin.Effects.RopeSpeedMultiplier;
				__state.Applied = true;
			}
		}

		private static Exception? Finalizer(CharacterRopeHandling __instance, State __state, Exception? __exception)
		{
			if (__state.Applied)
			{
				__instance.climbSpeedMod = __state.Original;
			}
			return __exception;
		}
	}
	[HarmonyPatch(typeof(CharacterVineClimbing), "FixedUpdate")]
	internal static class VineClimbingSpeedPatch
	{
		private struct State
		{
			public bool Applied;

			public float Original;

			public float OriginalSlideDeceleration;
		}

		private static void Prefix(CharacterVineClimbing __instance, Character ___character, out State __state)
		{
			__state = new State
			{
				Applied = false,
				Original = __instance.climbSpeedMod,
				OriginalSlideDeceleration = __instance.slideDeceleration
			};
			if (!((Object)(object)___character == (Object)null) && ___character.data.isVineClimbing && Plugin.Effects.CanApply(___character))
			{
				__instance.climbSpeedMod = __state.Original * Plugin.Effects.VineSpeedMultiplier;
				__instance.slideDeceleration = Mathf.Lerp(__state.OriginalSlideDeceleration, 1f, Plugin.Effects.VineMomentumRetention);
				__state.Applied = true;
			}
		}

		private static Exception? Finalizer(CharacterVineClimbing __instance, State __state, Exception? __exception)
		{
			if (__state.Applied)
			{
				__instance.climbSpeedMod = __state.Original;
				__instance.slideDeceleration = __state.OriginalSlideDeceleration;
			}
			return __exception;
		}
	}
	[HarmonyPatch(typeof(WindChillZone), "ApplyStatus")]
	internal static class WetGripWindCostPatch
	{
		private static void Prefix(Character character, out float __state)
		{
			__state = character?.refs?.climbing?.climbingStamMinimumMultiplier ?? 1f;
		}

		private static void Postfix(Character character, float __state)
		{
			CharacterClimbing val = character?.refs?.climbing;
			if (!((Object)(object)val == (Object)null) && Plugin.Effects.CanApply(character))
			{
				float climbingStamMinimumMultiplier = val.climbingStamMinimumMultiplier;
				if (climbingStamMinimumMultiplier > Math.Max(1f, __state))
				{
					val.climbingStamMinimumMultiplier = 1f + (climbingStamMinimumMultiplier - 1f) * Plugin.Effects.WetGripPenaltyMultiplier;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "UpdateVariablesFixed")]
	internal static class LowStaminaClimbingControlPatch
	{
		private static void Postfix(Character __instance)
		{
			if (Plugin.Effects.CanApply(__instance) && __instance.data.isClimbing && !(__instance.GetTotalStamina() >= 0.2f))
			{
				float num = Mathf.Clamp01(__instance.data.staminaMod);
				__instance.data.staminaMod = 1f - (1f - num) * Plugin.Effects.ClimbingTenacityPenaltyMultiplier;
			}
		}
	}
	[HarmonyPatch(typeof(CharacterClimbing), "Climbing")]
	internal static class LowStaminaClimbingSlidePatch
	{
		private struct State
		{
			public bool Applied;

			public float Original;
		}

		private static void Prefix(Character ___character, out State __state)
		{
			__state = default(State);
			if (!((Object)(object)___character == (Object)null) && Plugin.Effects.CanApply(___character) && !(___character.data.outOfStaminaClimbingFor <= 0f))
			{
				__state.Original = ___character.data.outOfStaminaClimbingFor;
				___character.data.outOfStaminaClimbingFor = __state.Original * Plugin.Effects.ClimbingTenacityPenaltyMultiplier;
				__state.Applied = true;
			}
		}

		private static Exception? Finalizer(Character ___character, State __state, Exception? __exception)
		{
			if (__state.Applied && (Object)(object)___character != (Object)null)
			{
				___character.data.outOfStaminaClimbingFor = __state.Original;
			}
			return __exception;
		}
	}
	internal static class ExplicitItemStatusScope
	{
		[ThreadStatic]
		private static int depth;

		public static bool Active => depth > 0;

		public static void Enter()
		{
			depth++;
		}

		public static void Exit()
		{
			depth = Math.Max(0, depth - 1);
		}
	}
	internal static class EnvironmentalColdRecoveryScope
	{
		[ThreadStatic]
		private static int depth;

		public static bool Active => depth > 0;

		public static void Enter()
		{
			depth++;
		}

		public static void Exit()
		{
			depth = Math.Max(0, depth - 1);
		}
	}
	[HarmonyPatch(typeof(Action_ModifyStatus), "RunAction")]
	internal static class ExplicitItemStatusScopePatch
	{
		private static void Prefix()
		{
			ExplicitItemStatusScope.Enter();
		}

		private static Exception? Finalizer(Exception? __exception)
		{
			ExplicitItemStatusScope.Exit();
			return __exception;
		}
	}
	internal static class FallScope
	{
		[ThreadStatic]
		private static string? source;

		public static string? Source => source;

		public static void Enter(string value)
		{
			source = value;
		}

		public static void Exit()
		{
			source = null;
		}
	}
	[HarmonyPatch(typeof(CharacterMovement), "CheckFallDamage")]
	internal static class NormalFallScopePatch
	{
		private static void Prefix()
		{
			FallScope.Enter("CharacterMovement");
		}

		private static Exception? Finalizer(Exception? __exception)
		{
			FallScope.Exit();
			return __exception;
		}
	}
	[HarmonyPatch(typeof(CharacterClimbing), "CheckFallDamage")]
	internal static class WallFallScopePatch
	{
		private static void Prefix()
		{
			FallScope.Enter("CharacterClimbing");
		}

		private static Exception? Finalizer(Exception? __exception)
		{
			FallScope.Exit();
			return __exception;
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
	internal static class AddStatusPatch
	{
		private struct State
		{
			public bool Local;

			public float Before;

			public float RawRequested;

			public STATUSTYPE StatusType;

			public string Source;

			public bool ToleranceExposure;

			public SkillId ToleranceSkill;

			public bool EnvironmentalColdRecovery;
		}

		private unsafe static void Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount, bool fromRPC, out State __state)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Invalid comparison between Unknown and I4
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)__instance != (Object)null && (Object)(object)__instance.character != (Object)null && (Object)(object)Character.localCharacter == (Object)(object)__instance.character;
			__state = new State
			{
				Local = flag,
				Before = (flag ? __instance.GetCurrentStatus(statusType) : 0f),
				RawRequested = amount,
				StatusType = statusType,
				Source = (fromRPC ? "AddRPC" : "AddLocal"),
				ToleranceExposure = false,
				ToleranceSkill = SkillId.Strength,
				EnvironmentalColdRecovery = false
			};
			string source = FallScope.Source;
			if (!flag || amount <= 0f)
			{
				return;
			}
			bool flag2 = (int)statusType == 8 && __instance.GetCurrentStatus((STATUSTYPE)2) > 0f;
			if (flag2 && !ExplicitItemStatusScope.Active)
			{
				EnvironmentalColdRecoveryScope.Enter();
				__state.EnvironmentalColdRecovery = true;
			}
			SkillId skillId;
			if ((int)statusType == 0 && source != null)
			{
				float num = amount;
				Plugin.Progression.AwardWork(SkillId.Vitality, num, Plugin.Settings.VitalityXpPerInjury.Value, source);
				if (Plugin.Effects.CanApply(__instance.character))
				{
					amount *= Plugin.Effects.VitalityFallMultiplier;
				}
				__state.Source = "Fall:" + source;
				Plugin.Diagnostics?.RecordFall(num, amount, source);
			}
			else if ((int)statusType == 13)
			{
				__state.Local = false;
			}
			else if (ConditionSkillAdapter.TryGetToleranceSkill(statusType, out skillId))
			{
				__state.ToleranceExposure = true;
				__state.ToleranceSkill = skillId;
				__state.Source = "Exposure:" + ((object)(*(STATUSTYPE*)(&statusType))/*cast due to .constrained prefix*/).ToString();
				if (!flag2 && Plugin.Effects.CanApply(__instance.character))
				{
					amount *= Plugin.Effects.ConditionGainMultiplier(skillId);
				}
			}
		}

		private unsafe static void Postfix(CharacterAfflictions __instance, bool __result, State __state)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (__state.Local)
			{
				float currentStatus = __instance.GetCurrentStatus(__state.StatusType);
				float num = currentStatus - __state.Before;
				if (__state.ToleranceExposure && __state.ToleranceSkill != SkillId.HungerTolerance && __result && num > 0f)
				{
					Plugin.Progression.AwardWork(__state.ToleranceSkill, num, Plugin.Settings.ConditionXpPerStatus.Value, __state.Source);
				}
				Plugin.Diagnostics?.RecordStatusChange(((object)(*(STATUSTYPE*)(&__state.StatusType))/*cast due to .constrained prefix*/).ToString(), __state.RawRequested, num, currentStatus, __state.Source);
			}
		}

		private static Exception? Finalizer(Exception? __exception, State __state)
		{
			if (__state.EnvironmentalColdRecovery)
			{
				EnvironmentalColdRecoveryScope.Exit();
			}
			return __exception;
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "AddPetrify", new Type[] { typeof(int) })]
	internal static class AddPetrifyPatch
	{
		private struct State
		{
			public bool Local;

			public int Before;

			public int RawRequested;
		}

		private static void Prefix(CharacterAfflictions __instance, ref int petrify, out State __state)
		{
			bool flag = (Object)(object)__instance != (Object)null && (Object)(object)__instance.character != (Object)null && (Object)(object)Character.localCharacter == (Object)(object)__instance.character;
			__state = new State
			{
				Local = flag,
				Before = (flag ? __instance.character.data.petrifyAmount : 0),
				RawRequested = petrify
			};
			if (flag && petrify > 0 && Plugin.Effects.CanApply(__instance.character))
			{
				petrify = Mathf.Max(0, Mathf.RoundToInt((float)petrify * Plugin.Effects.ConditionGainMultiplier(SkillId.PetrificationResistance)));
			}
		}

		private static void Postfix(CharacterAfflictions __instance, State __state)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (__state.Local && __state.RawRequested > 0)
			{
				int petrifyAmount = __instance.character.data.petrifyAmount;
				int num = Mathf.Max(0, petrifyAmount - __state.Before);
				if (num > 0)
				{
					Plugin.Progression.AwardWork(SkillId.PetrificationResistance, (double)num / 100.0, Plugin.Settings.ConditionXpPerStatus.Value, "Exposure:Petrify");
				}
				Plugin.Diagnostics?.RecordStatusChange(((object)(STATUSTYPE)13/*cast due to .constrained prefix*/).ToString(), (float)__state.RawRequested / 100f, (float)num / 100f, (float)petrifyAmount / 100f, "Exposure:Petrify");
			}
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "SubtractStatus")]
	internal static class SubtractStatusPatch
	{
		private struct State
		{
			public bool Local;

			public float Before;

			public float Requested;

			public STATUSTYPE StatusType;

			public string Source;

			public bool HasRecoveryTolerance;

			public SkillId RecoveryTolerance;
		}

		private unsafe static void Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount, bool fromRPC, bool decreasedNaturally, out State __state)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_005c: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)__instance != (Object)null && (Object)(object)__instance.character != (Object)null && (Object)(object)Character.localCharacter == (Object)(object)__instance.character;
			bool flag2 = (int)statusType == 2 && EnvironmentalColdRecoveryScope.Active;
			bool flag3 = decreasedNaturally || flag2;
			__state = new State
			{
				Local = flag,
				Before = (flag ? __instance.GetCurrentStatus(statusType) : 0f),
				Requested = amount,
				StatusType = statusType,
				Source = (flag2 ? "NaturalRecovery:ColdByWarmth" : (decreasedNaturally ? "NaturalRecovery" : (fromRPC ? "SubtractRPC" : "SubtractLocal"))),
				HasRecoveryTolerance = ConditionSkillAdapter.TryGetRecoveryTolerance(statusType, out var skillId),
				RecoveryTolerance = skillId
			};
			if (flag && flag3 && amount > 0f && __state.HasRecoveryTolerance && Plugin.Effects.CanApply(__instance.character))
			{
				amount *= Plugin.Effects.ConditionRecoveryMultiplier(__state.RecoveryTolerance);
				if (!flag2)
				{
					__state.Source = "NaturalRecovery:" + ((object)(*(STATUSTYPE*)(&statusType))/*cast due to .constrained prefix*/).ToString();
				}
			}
		}

		private unsafe static void Postfix(CharacterAfflictions __instance, State __state)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (__state.Local)
			{
				float currentStatus = __instance.GetCurrentStatus(__state.StatusType);
				float actual = currentStatus - __state.Before;
				Plugin.Diagnostics?.RecordStatusChange(((object)(*(STATUSTYPE*)(&__state.StatusType))/*cast due to .constrained prefix*/).ToString(), 0f - __state.Requested, actual, currentStatus, __state.Source);
			}
		}
	}
	[HarmonyPatch(typeof(BackpackData), "DeserializeValue")]
	internal static class BackpackDataDeserializePatch
	{
		private static bool Prefix(BackpackData __instance, BinaryDeserializer deserializer)
		{
			//IL_0002: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			InventorySyncData val = default(InventorySyncData);
			((InventorySyncData)(ref val)).Deserialize(deserializer);
			SlotData[] array = val.slots ?? Array.Empty<SlotData>();
			int num = array.Length;
			ItemSlot[] itemSlots = __instance.itemSlots;
			int val2 = ((itemSlots != null) ? itemSlots.Length : 0);
			int num2 = Math.Max(num, val2);
			ItemSlot[] array2 = __instance.itemSlots ?? Array.Empty<ItemSlot>();
			if (array2.Length < num2)
			{
				Array.Resize(ref array2, num2);
				__instance.itemSlots = array2;
			}
			Item val5 = default(Item);
			for (int i = 0; i < array2.Length; i++)
			{
				ItemSlot[] array3 = array2;
				int num3 = i;
				if (array3[num3] == null)
				{
					array3[num3] = new ItemSlot((byte)i);
				}
				if (i < num)
				{
					SlotData val3 = array[i];
					Item val4 = (ItemDatabase.TryGetItem(val3.ItemID, ref val5) ? val5 : null);
					array2[i].SetItem(val4, val3.Data);
				}
				else
				{
					array2[i].SetItem((Item)null, (ItemInstanceData)null);
				}
			}
			Plugin.ModLog.LogInfo((object)($"[UsageSkills:Inventory] backpack deserialized serialized={num} " + $"retainedCapacity={array2.Length}"));
			return false;
		}
	}
	[HarmonyPatch(typeof(BackpackWheel), "InitWheel")]
	internal static class BackpackWheelCapacityPatch
	{
		private static void Prefix(BackpackWheel __instance, BackpackReference bp, ref int slotCount, BackpackType backpackType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			if (!InventorySkillService.IsItemStorage(backpackType))
			{
				return;
			}
			BackpackData data = ((BackpackReference)(ref bp)).GetData();
			slotCount = InventorySkillService.EnsureBackpackCapacity(data, backpackType, "WheelOpen");
			int num = Math.Max(slotCount, data.itemSlots.Length) + 1;
			if (__instance.slices.Length < num)
			{
				List<BackpackWheelSlice> list = new List<BackpackWheelSlice>(__instance.slices);
				BackpackWheelSlice val = __instance.slices[Math.Min(1, __instance.slices.Length - 1)];
				while (list.Count < num)
				{
					list.Add(Object.Instantiate<BackpackWheelSlice>(val, ((Component)val).transform.parent));
				}
				__instance.slices = list.ToArray();
			}
			int num2 = slotCount + 1;
			float num3 = 158f + (float)Math.Max(0, num2 - 5) * 20f;
			for (int i = 0; i < num2; i++)
			{
				float num4 = 360f / (float)num2 * (float)i + 158f;
				float num5 = (num4 + 112f) * (MathF.PI / 180f);
				Transform transform = ((Component)__instance.slices[i]).transform;
				transform.localRotation = Quaternion.Euler(0f, 0f, num4);
				transform.localPosition = new Vector3(Mathf.Cos(num5) * num3, Mathf.Sin(num5) * num3, 0f);
			}
		}
	}
	[HarmonyPatch(typeof(BackpackVisuals), "RefreshVisuals")]
	internal static class BackpackVisualCapacityPatch
	{
		private static void Prefix(BackpackVisuals __instance)
		{
			//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_0007: 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)
			BackpackType backpackType = GetBackpackType(__instance);
			if (!InventorySkillService.IsItemStorage(backpackType))
			{
				return;
			}
			BackpackData backpackData = __instance.GetBackpackData();
			if (backpackData == null || __instance.backpackSlots == null || __instance.backpackSlots.Length == 0)
			{
				return;
			}
			int num = InventorySkillService.EnsureBackpackCapacity(backpackData, backpackType, "BackpackVisuals");
			if (__instance.backpackSlots.Length < num)
			{
				Transform[] backpackSlots = __instance.backpackSlots;
				Transform[] array = (Transform[])(object)new Transform[num];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = backpackSlots[i % backpackSlots.Length];
				}
				__instance.backpackSlots = array;
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(BackpackVisualCapacityPatch), "GetVisualSlotCount", (Type[])null, (Type[])null);
			for (int i = 0; i + 1 < list.Count; i++)
			{
				if (CodeInstructionExtensions.LoadsConstant(list[i], 4L) && (list[i + 1].opcode == OpCodes.Blt || list[i + 1].opcode == OpCodes.Blt_S))
				{
					list[i].opcode = OpCodes.Ldarg_0;
					list[i].operand = null;
					list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)methodInfo));
					break;
				}
			}
			return list;
		}

		private static int GetVisualSlotCount(BackpackVisuals visuals)
		{
			//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_0007: 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)
			BackpackType backpackType = GetBackpackType(visuals);
			if (!InventorySkillService.IsItemStorage(backpackType))
			{
				return 0;
			}
			return InventorySkillService.EnsureBackpackCapacity(visuals.GetBackpackData(), backpackType, "VisualRefresh");
		}

		private static BackpackType GetBackpackType(BackpackVisuals visuals)
		{
			//IL_000b: 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)
			BackpackOnBackVisuals val = (BackpackOnBackVisuals)(object)((visuals is BackpackOnBackVisuals) ? visuals : null);
			if (val != null)
			{
				return val.backpackType;
			}
			Backpack component = ((Component)visuals).GetComponent<Backpack>();
			if (!((Object)(object)component != (Object)null))
			{
				return (BackpackType)0;
			}
			return component.backpackType;
		}
	}
	[HarmonyPatch(typeof(CharacterMovement), "GetMovementForce")]
	internal static class AthleticsMovementPatch
	{
		private static void Postfix(Character ___character, ref float __result)
		{
			if (!(__result <= 0f) && !((Object)(object)___character == (Object)null) && Plugin.Effects.CanApply(___character) && ___character.data.isGrounded && !___character.data.isClimbingAnything)
			{
				__result *= Plugin.Effects.AthleticsMovementMultiplier;
				if (___character.data.isSprinting)
				{
					__result *= Plugin.Effects.AthleticsSprintMovementMultiplier;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "CalculateWorldMovementDir")]
	internal static class AgilityAirControlPatch
	{
		private struct State
		{
			public bool Applied;

			public float Original;
		}

		private static void Prefix(Character __instance, out State __state)
		{
			__state = default(State);
			CharacterMovement val = __instance.refs?.movement;
			if (!((Object)(object)val == (Object)null) && !__instance.data.isGrounded && !__instance.data.isClimbingAnything && Plugin.Effects.CanApply(__instance))
			{
				__state.Original = val.airMovementTurnSpeed;
				val.airMovementTurnSpeed = __state.Original * Plugin.Effects.AgilityAirControlMultiplier;
				__state.Applied = true;
			}
		}

		private static Exception? Finalizer(Character __instance, State __state, Exception? __exception)
		{
			if (__state.Applied && (Object)(object)__instance?.refs?.movement != (Object)null)
			{
				__instance.refs.movement.airMovementTurnSpeed = __state.Original;
			}
			return __exception;
		}
	}
	[HarmonyPatch(typeof(CharacterMovement), "JumpRpc")]
	internal static class AgilityJumpAwardPatch
	{
		private static void Prefix(Character ___character, bool isPalJump)
		{
			if (!((Object)(object)___character == (Object)null || (Object)(object)Character.localCharacter != (Object)(object)___character || isPalJump))
			{
				Plugin.Progression.AwardWork(SkillId.Agility, 1.0, Plugin.Settings.AgilityXpPerJump.Value, "ExecutedJump");
			}
		}
	}
	internal static class JumpEffectScope
	{
		[ThreadStatic]
		private static Character? character;

		[ThreadStatic]
		private static int depth;

		public static bool Matches(Character candidate)
		{
			if (depth > 0)
			{
				return (Object)(object)character == (Object)(object)candidate;
			}
			return false;
		}

		public static void Enter(Character value)
		{
			character = value;
			depth++;
		}

		public static void Exit()
		{
			depth = Math.Max(0, depth - 1);
			if (depth == 0)
			{
				character = null;
			}
		}
	}
	[HarmonyPatch]
	internal static class AgilityJumpRoutinePatch
	{
		private struct State
		{
			public CharacterMovement? Movement;

			public float OriginalJumpImpulse;

			public bool Applied;

			public bool ScopeEntered;
		}

		private static readonly FieldInfo MovementCharacterField = AccessTools.Field(typeof(CharacterMovement), "character");

		private static readonly FieldInfo JumpImpulseField = AccessTools.Field(typeof(CharacterMovement), "jumpImpulse");

		private static MethodBase TargetMethod()
		{
			Type type = (typeof(CharacterMovement).GetNestedType("<>c__DisplayClass69_0", BindingFlags.NonPublic) ?? throw new MissingMemberException("CharacterMovement jump display class")).GetNestedType("<<JumpRpc>g__IDoJump|0>d", BindingFlags.NonPublic) ?? throw new MissingMemberException("CharacterMovement jump iterator");
			return AccessTools.Method(type, "MoveNext", (Type[])null, (Type[])null) ?? throw new MissingMethodException(type.FullName, "MoveNext");
		}

		private static void Prefix(object __instance, out State __state)
		{
			__state = default(State);
			object obj = AccessTools.Field(__instance.GetType(), "<>4__this")?.GetValue(__instance);
			object? obj2 = ((obj == null) ? null : AccessTools.Field(obj.GetType(), "<>4__this"))?.GetValue(obj);
			CharacterMovement val = (CharacterMovement)((obj2 is CharacterMovement) ? obj2 : null);
			Character val2 = (Character)(((Object)(object)val == (Object)null) ? null : /*isinst with value type is only supported in some contexts*/);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null) && !((Object)(object)Character.localCharacter != (Object)(object)val2))
			{
				__state.Movement = val;
				JumpEffectScope.Enter(val2);
				__state.ScopeEntered = true;
				if (Plugin.Effects.CanApply(val2))
				{
					__state.OriginalJumpImpulse = (float)JumpImpulseField.GetValue(val);
					JumpImpulseField.SetValue(val, __state.OriginalJumpImpulse * Plugin.Effects.AgilityJumpMultiplier);
					__state.Applied = true;
				}
			}
		}

		private static Exception? Finalizer(State __state, Exception? __exception)
		{
			if (__state.Applied && (Object)(object)__state.Movement != (Object)null)
			{
				JumpImpulseField.SetValue(__state.Movement, __state.OriginalJumpImpulse);
			}
			if (__state.ScopeEntered)
			{
				JumpEffectScope.Exit();
			}
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Character), "GetMaxStamina")]
	internal static class StaminaCapacityPatch
	{
		private static void Postfix(Character __instance, ref float __result)
		{
			if (Plugin.Effects.CanApply(__instance))
			{
				float capacityBonus = Plugin.Effects.EnduranceCapacityMultiplier - 1f;
				CharacterRefs refs = __instance.refs;
				float? obj;
				if (refs == null)
				{
					obj = null;
				}
				else
				{
					CharacterAfflictions afflictions = refs.afflictions;
					obj = ((afflictions != null) ? new float?(afflictions.statusSum) : ((float?)null));
				}
				float? num = obj;
				float valueOrDefault = num.GetValueOrDefault();
				__result = SkillMath.ExpandedStaminaCapacity(__result, valueOrDefault, capacityBonus);
			}
		}
	}
	internal static class EndurancePassOutThreshold
	{
		public static float GetThreshold(Character character)
		{
			if ((Object)(object)character == (Object)null || !Plugin.Effects.CanApply(character))
			{
				return 1f;
			}
			return Math.Max(1f, Plugin.Effects.EnduranceCapacityMultiplier);
		}

		public static IEnumerable<CodeInstruction> ReplaceVanillaThreshold(IEnumerable<CodeInstruction> instructions, MethodBase originalMethod)
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(CharacterAfflictions), "statusSum") ?? AccessTools.Method(typeof(CharacterAfflictions), "get_statusSum", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(EndurancePassOutThreshold), "GetThreshold", (Type[])null, (Type[])null);
			if (methodInfo == null || methodInfo2 == null)
			{
				Plugin.ModLog.LogError((object)("[UsageSkills:PassOut] Could not resolve statusSum getter/threshold method while patching " + originalMethod.Name + "."));
				return list;
			}
			int num = 0;
			for (int i = 1; i < list.Count; i++)
			{
				CodeInstruction val = list[i - 1];
				CodeInstruction val2 = list[i];
				bool num2 = (val.opcode == OpCodes.Call || val.opcode == OpCodes.Callvirt) && object.Equals(val.operand, methodInfo);
				bool flag = val2.opcode == OpCodes.Ldc_R4 && val2.operand is float num3 && Math.Abs(num3 - 1f) < 0.0001f;
				if (num2 && flag)
				{
					val2.opcode = OpCodes.Ldarg_0;
					val2.operand = null;
					list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)methodInfo2));
					num++;
					i++;
				}
			}
			if (num == 0)
			{
				Plugin.ModLog.LogError((object)("[UsageSkills:PassOut] No vanilla statusSum vs 1.0 threshold found in " + originalMethod.Name + ". Endurance pass-out scaling will not affect this method."));
			}
			else
			{
				Plugin.ModLog.LogInfo((object)$"[UsageSkills:PassOut] Patched {originalMethod.Name} threshold(s)={num}.");
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(Character), "HandlePassedOut")]
	internal static class EndurancePassOutRecoveryPatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod)
		{
			return EndurancePassOutThreshold.ReplaceVanillaThreshold(instructions, __originalMethod);
		}
	}
	[HarmonyPatch(typeof(Character), "UseStamina")]
	internal static class StaminaCostPatch
	{
		private static void Prefix(Character __instance, ref float usage)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)Character.localCharacter != (Object)(object)__instance || usage <= 0f)
			{
				return;
			}
			float num = usage;
			bool flag = JumpEffectScope.Matches(__instance);
			bool flag2 = __instance.data.isClimbing && !__instance.data.isRopeClimbing && !__instance.data.isVineClimbing;
			string source = (flag ? "Jumping" : (flag2 ? "WallClimbing" : (__instance.data.isRopeClimbing ? "RopeClimbing" : (__instance.data.isVineClimbing ? "VineClimbing" : (__instance.data.isSprinting ? "Sprinting" : "OtherExertion")))));
			if (!__instance.infiniteStam)
			{
				Plugin.Progression.AwardWork(SkillId.Endurance, num, Plugin.Settings.EnduranceXpPerStamina.Value, source);
			}
			if (Plugin.Effects.CanApply(__instance))
			{
				if (flag2)
				{
					usage *= Plugin.Effects.WallCostMultiplier;
					if (__instance.GetTotalStamina() < 0.2f)
					{
						usage *= Plugin.Effects.ClimbingTenacityPenaltyMultiplier;
					}
				}
				else if (__instance.data.isRopeClimbing)
				{
					usage *= Plugin.Effects.RopeCostMultiplier;
				}
				else if (__instance.data.isVineClimbing)
				{
					usage *= Plugin.Effects.VineCostMultiplier;
				}
				else if (flag)
				{
					usage *= Plugin.Effects.AgilityJumpCostMultiplier;
				}
				else if (__instance.data.isSprinting)
				{
					usage *= Plugin.Effects.AthleticsSprintCostMultiplier;
				}
			}
			Plugin.Diagnostics?.RecordStaminaRequest(num, usage, source);
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "get_shouldPassOut")]
	internal static class EnduranceShouldPassOutThresholdPatch
	{
		private static void Postfix(CharacterAfflictions __instance, ref bool __result)
		{
			if (!__result || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			Character character = __instance.character;
			if ((Object)(object)character == (Object)null || (Object)(object)Character.localCharacter != (Object)(object)character || !Plugin.Effects.CanApply(character))
			{
				return;
			}
			float enduranceCapacityMultiplier = Plugin.Effects.EnduranceCapacityMultiplier;
			if (!(enduranceCapacityMultiplier <= 1.0001f))
			{
				float statusSum = __instance.statusSum;
				if (statusSum >= 1f && statusSum < enduranceCapacityMultiplier)
				{
					__result = false;
				}
			}
		}
	}
	internal static class RegenScope
	{
		[ThreadStatic]
		private static int depth;

		public static bool Active => depth > 0;

		public static void Enter()
		{
			depth++;
		}

		public static void Exit()
		{
			depth = Math.Max(0, depth - 1);
		}
	}
	[HarmonyPatch(typeof(Character), "UpdateVariablesFixed")]
	internal static class StaminaRegenScopePatch
	{
		private static void Prefix(Character __instance, out bool __state)
		{
			__state = (Object)(object)Character.localCharacter == (Object)(object)__instance;
			if (__state)
			{
				RegenScope.Enter();
			}
		}

		private static Exception? Finalizer(bool __state, Exception? __exception)
		{
			if (__state)
			{
				RegenScope.Exit();
			}
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Character), "AddStamina")]
	internal static class StaminaRegenAmountPatch
	{
		private static void Prefix(Character __instance, [HarmonyArgument(0)] ref float amount)
		{
			if (RegenScope.Active && amount > 0f && Plugin.Effects.CanApply(__instance))
			{
				amount *= Plugin.Effects.EnduranceRegenMultiplier;
			}
		}
	}
	[HarmonyPatch(typeof(StaminaBar), "Update")]
	[HarmonyAfter(new string[] { "com.github.LengSword.PeakStatsEx" })]
	[HarmonyPriority(0)]
	internal static class StaminaBarVisualPatch
	{
		private sealed class Baseline
		{
			public float BackingWidth { get; set; }

			public float OutlineWidth { get; set; }

			public float BackingLeft { get; set; }

			public float OutlineLeft { get; set; }

			public float FullBarLeft { get; set; }

			public float StaminaBarLeft { get; set; }

			public float MaxStaminaBarLeft { get; set; }

			public float ExtraBarLeft { get; set; }

			public RectTransform? StatusLayout { get; set; }

			public float StatusLayoutWidth { get; set; }

			public float StatusLayoutLeft { get; set; }

			public float LastLoggedCapacity { get; set; } = float.NaN;

			public int LastLoggedScreenWidth { get; set; } = -1;

			public int LastLoggedScreenHeight { get; set; } = -1;
		}

		private const float VanillaOutlinePadding = 14f;

		private static readonly ConditionalWeakTable<StaminaBar, Baseline> Baselines = new ConditionalWeakTable<StaminaBar, Baseline>();

		private static readonly Vector3[] WorldCorners = (Vector3[])(object)new Vector3[4];

		private static void Postfix(StaminaBar __instance)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.fullBar == (Object)null || (Object)(object)__instance.staminaBar == (Object)null || (Object)(object)__instance.maxStaminaBar == (Object)null || (Object)(object)__instance.backing == (Object)null || (Object)(object)__instance.staminaBarOutline == (Object)null)
			{
				return;
			}
			Transform parent = ((Component)__instance).transform.parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			float x = __instance.fullBar.sizeDelta.x;
			if (x <= 1f)
			{
				return;
			}
			Rect rect;
			if (!Baselines.TryGetValue(__instance, out Baseline value))
			{
				Transform parent2 = ((Transform)__instance.maxStaminaBar).parent;
				RectTransform val2 = (RectTransform)(object)((parent2 is RectTransform) ? parent2 : null);
				Baseline baseline = new Baseline();
				rect = ((Graphic)__instance.backing).rectTransform.rect;
				baseline.BackingWidth = ((Rect)(ref rect)).width;
				rect = __instance.staminaBarOutline.rect;
				baseline.OutlineWidth = ((Rect)(ref rect)).width;
				baseline.BackingLeft = GetLeft(val, ((Graphic)__instance.backing).rectTransform);
				baseline.OutlineLeft = GetLeft(val, __instance.staminaBarOutline);
				baseline.FullBarLeft = GetLeft(val, __instance.fullBar);
				baseline.StaminaBarLeft = GetLeft(val, __instance.staminaBar);
				baseline.MaxStaminaBarLeft = GetLeft(val, __instance.maxStaminaBar);
				baseline.ExtraBarLeft = (((Object)(object)__instance.extraBar != (Object)null) ? GetLeft(val, __instance.extraBar) : 0f);
				baseline.StatusLayout = val2;
				float statusLayoutWidth;
				if (!((Object)(object)val2 != (Object)null))
				{
					statusLayoutWidth = 0f;
				}
				else
				{
					rect = val2.rect;
					statusLayoutWidth = ((Rect)(ref rect)).width;
				}
				baseline.StatusLayoutWidth = statusLayoutWidth;
				baseline.StatusLayoutLeft = (((Object)(object)val2 != (Object)null) ? GetLeft(val, val2) : 0f);
				value = baseline;
				Baselines.Add(__instance, value);
			}
			float enduranceCapacityMultiplier = Plugin.Effects.EnduranceCapacityMultiplier;
			bool flag = Plugin.Settings.ExtendStaminaBar.Value && Plugin.Effects.CanApply(Character.observedCharacter) && enduranceCapacityMultiplier > 1.0001f;
			float num = (flag ? (x * (enduranceCapacityMultiplier - 1f)) : 0f);
			float num2 = x + num;
			SetRenderedWidthAndLeft(val, ((Graphic)__instance.backing).rectTransform, num2, value.BackingLeft);
			SetLeft(val, __instance.fullBar, value.FullBarLeft);
			SetLeft(val, __instance.staminaBar, value.StaminaBarLeft);
			if ((Object)(object)value.StatusLayout != (Object)null && (Object)(object)value.StatusLayout != (Object)(object)__instance.fullBar && (Object)(object)value.StatusLayout != (Object)(object)((Graphic)__instance.backing).rectTransform)
			{
				SetRenderedWidthAndLeft(val, value.StatusLayout, num2, value.StatusLayoutLeft);
			}
			SetLeft(val, __instance.maxStaminaBar, value.MaxStaminaBarLeft);
			SetRenderedWidthAndLeft(val, __instance.staminaBarOutline, num2 + 14f, value.OutlineLeft);
			if ((Object)(object)__instance.extraBar != (Object)null)
			{
				SetLeft(val, __instance.extraBar, value.ExtraBarLeft);
			}
			UpdatePreciseWeightText(__instance, x);
			DiagnosticHub? diagnostics = Plugin.Diagnostics;
			if (diagnostics != null)
			{
				rect = ((Graphic)__instance.backing).rectTransform.rect;
				float width = ((Rect)(ref rect)).width;
				rect = __instance.staminaBarOutline.rect;
				diagnostics.RecordBar(x, width, ((Rect)(ref rect)).width);
			}
			bool num3 = float.IsNaN(value.LastLoggedCapacity) || Math.Abs(value.LastLoggedCapacity - enduranceCapacityMultiplier) >= 0.0001f;
			bool flag2 = value.LastLoggedScreenWidth != Screen.width || value.LastLoggedScreenHeight != Screen.height;
			if (num3 || flag2)
			{
				value.LastLoggedCapacity = enduranceCapacityMultiplier;
				value.LastLoggedScreenWidth = Screen.width;
				value.LastLoggedScreenHeight = Screen.height;
				Mask[] componentsInParent = ((Component)__instance).GetComponentsInParent<Mask>(true);
				RectMask2D[] componentsInParent2 = ((Component)__instance).GetComponentsInParent<RectMask2D>(true);
				Plugin.ModLog.LogInfo((object)($"[UsageSkills:StaminaBar] extend={flag} capacity={enduranceCapacityMultiplier:F4} " + $"frameTarget={num2:F2} extraPx={num:F2} " + $"unitWidth={x:F2} screen={Screen.width}x{Screen.height} " + $"backingBase={value.BackingWidth:F2} outlineBase={value.OutlineWidth:F2} " + $"parentMasks={componentsInParent.Length} parentRectMasks={componentsInParent2.Length} path={BuildPath(((Component)__instance).transform)} " + "backing=[" + DescribeRect(val, ((Graphic)__instance.backing).rectTransform) + "] outline=[" + DescribeRect(val, __instance.staminaBarOutline) + "] full=[" + DescribeRect(val, __instance.fullBar) + "] current=[" + DescribeRect(val, __instance.staminaBar) + "] max=[" + DescribeRect(val, __instance.maxStaminaBar) + "] statusLayout=[" + DescribeOptionalRect(val, value.StatusLayout) + "] afflictions=[" + DescribeAfflictions(val, __instance.afflictions) + "]"));
			}
		}

		private static void SetRenderedWidthAndLeft(RectTransform reference, RectTransform transform, float width, float left)
		{
			//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_0009: 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_0015: 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)
			Vector2 sizeDelta = transform.sizeDelta;
			float x = sizeDelta.x;
			Rect rect = transform.rect;
			sizeDelta.x = SkillMath.SizeDeltaForRenderedWidth(x, ((Rect)(ref rect)).width, width);
			transform.sizeDelta = sizeDelta;
			SetLeft(reference, transform, left);
		}

		private static void UpdatePreciseWeightText(StaminaBar staminaBar, float unitWidth)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			if (staminaBar.afflictions == null || unitWidth <= 0f)
			{
				return;
			}
			BarAffliction[] afflictions = staminaBar.afflictions;
			foreach (BarAffliction val in afflictions)
			{
				if ((Object)(object)val == (Object)null || (int)val.afflictionType != 7)
				{
					continue;
				}
				Transform obj = ((Component)val).transform.Find("StaminaInfo");
				TextMeshProUGUI val2 = ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null);
				if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeSelf)
				{
					string text = ((TMP_Text)val2).text ?? string.Empty;
					int num = text.IndexOf('(');
					string text2 = ((num >= 0) ? text.Substring(num) : string.Empty);
					string text3 = (val.size / unitWidth * 100f).ToString("F1", CultureInfo.InvariantCulture) + text2;
					if (!string.Equals(text, text3, StringComparison.Ordinal))
					{
						((TMP_Text)val2).text = text3;
					}
				}
				break;
			}
		}

		private static void SetLeft(RectTransform reference, RectTransform transform, float left)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			float num = left - GetLeft(reference, transform);
			if (!(Math.Abs(num) < 0.001f))
			{
				((Transform)transform).position = ((Transform)transform).position + ((Transform)reference).TransformVector(new Vector3(num, 0f, 0f));
			}
		}

		private static float GetLeft(RectTransform reference, RectTransform transform)
		{
			//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)
			transform.GetWorldCorners(WorldCorners);
			return ((Transform)reference).InverseTransformPoint(WorldCorners[0]).x;
		}

		private static string DescribeRect(RectTransform reference, RectTransform transform)
		{
			//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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_006f: 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)
			string name = ((Object)transform).name;
			object arg = GetLeft(reference, transform);
			Rect rect = transform.rect;
			return $"name={name},left={arg:F2},rectW={((Rect)(ref rect)).width:F2}," + $"sizeX={transform.sizeDelta.x:F2},posX={transform.anchoredPosition.x:F2}," + $"anchor={transform.anchorMin.x:F2}/{transform.anchorMax.x:F2},pivot={transform.pivot.x:F2}";
		}

		private static string DescribeOptionalRect(RectTransform reference, RectTransform? transform)
		{
			if (!((Object)(object)transform == (Object)null))
			{
				return DescribeRect(reference, transform) + ",path=" + BuildPath((Transform)(object)transform);
			}
			return "none";
		}

		private static string DescribeAfflictions(RectTransform reference, BarAffliction[]? afflictions)
		{
			if (afflictions == null || afflictions.Length == 0)
			{
				return "none";
			}
			string[] array = new string[afflictions.Length];
			for (int i = 0; i < afflictions.Length; i++)
			{
				BarAffliction val = afflictions[i];
				array[i] = (((Object)(object)val == (Object)null || (Object)(object)val.rtf == (Object)null) ? "missing" : (((object)Unsafe.As<STATUSTYPE, STATUSTYPE>(ref val.afflictionType)/*cast due to .constrained prefix*/).ToString() + ":" + DescribeRect(reference, val.rtf) + ",path=" + BuildPath((Transform)(object)val.rtf)));
			}
			return string.Join(";", array);
		}

		private static string BuildPath(Transform transform)
		{
			string text = ((Object)transform).name;
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "UpdateWeight")]
	[HarmonyAfter(new string[] { "nakazora.peak.piggyback" })]
	[HarmonyPriority(0)]
	internal static class WeightPatch
	{
		private static readonly MethodInfo? UpdateWeightMethod = AccessTools.Method(typeof(CharacterAfflictions), "UpdateWeight", (Type[])null, (Type[])null);

		private static void Postfix(CharacterAfflictions __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.character == (Object)null || (Object)(object)Character.localCharacter != (Object)(object)__instance.character)
			{
				return;
			}
			float currentStatus = __instance.GetCurrentStatus((STATUSTYPE)7);
			float num = currentStatus;
			if (currentStatus > 0f && Plugin.Effects.CanApply(__instance.character))
			{
				num = currentStatus * Plugin.Effects.StrengthWeightMultiplier;
				if (Math.Abs(num - currentStatus) > 1E-05f)
				{
					__instance.SetStatus((STATUSTYPE)7, num, true);
				}
			}
			Plugin.Diagnostics?.RecordWeight(currentStatus, num);
		}

		internal static void RefreshLocalWeight(string source)
		{
			CharacterAfflictions val = Character.localCharacter?.refs?.afflictions;
			if ((Object)(object)val == (Object)null || UpdateWeightMethod == null)
			{
				Plugin.ModLog.LogWarning((object)$"[UsageSkills:Weight] refresh skipped source={source} localAfflictions={(Object)(object)val != (Object)null}");
				return;
			}
			try
			{
				UpdateWeightMethod.Invoke(val, null);
				Plugin.ModLog.LogInfo((object)("[UsageSkills:Weight] refreshed source=" + source));
			}
			catch (Exception arg)
			{
				Plugin.ModLog.LogError((object)$"[UsageSkills:Weight] refresh failed source={source}: {arg}");
			}
		}
	}
}
namespace PEAKUsageSkills.Effects
{
	internal sealed class EffectService
	{
		private readonly UsageSkillsConfig config;

		private readonly ProgressionService progression;

		private readonly RunStateAdapter runState;

		public float EnduranceCapacityMultiplier => 1f + SkillMath.LinearBonus(GetEffectiveLevel(SkillId.Endurance), config.EnduranceCapacityPerLevel.Value);

		public float EnduranceRegenMultiplier => 1f + SkillMath.LinearBonus(GetEffectiveLevel(SkillId.Endurance), config.EnduranceRegenPerLevel.Value);

		public float EnduranceCostMultiplier => 1f;

		public float StrengthWeightMultiplier => SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(SkillId.Strength), config.StrengthReductionPerLevel.Value);

		public float WallSpeedMultiplier => 1f + SkillMath.LinearBonus(GetEffectiveLevel(SkillId.WallClimbing), config.WallSpeedPerLevel.Value);

		public float WallCostMultiplier => SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(SkillId.WallClimbing), config.WallCostReductionPerLevel.Value);

		public float RopeSpeedMultiplier => 1f + SkillMath.LinearBonus(GetEffectiveLevel(SkillId.RopeClimbing), config.RopeSpeedPerLevel.Value);

		public float RopeCostMultiplier => SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(SkillId.RopeClimbing), config.RopeCostEfficiencyPerLevel.Value);

		public float VineSpeedMultiplier => 1f + SkillMath.LinearBonus(GetEffectiveLevel(SkillId.VineClimbing), config.VineSpeedPerLevel.Value);

		public float VineCostMultiplier => SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(SkillId.VineClimbing), config.VineCostEfficiencyPerLevel.Value);

		public float AthleticsMovementMultiplier => 1f + SkillMath.LinearBonus(GetEffectiveLevel(SkillId.Athletics), config.AthleticsMovementPerLevel.Value);

		public float AthleticsSprintMovementMultiplier => 1f + SkillMath.LinearBonus(GetEffectiveLevel(SkillId.Athletics), config.AthleticsSprintMovementPerLevel.Value);

		public float AthleticsSprintCostMultiplier => SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(SkillId.Athletics), config.AthleticsSprintEfficiencyPerLevel.Value);

		public float AgilityJumpMultiplier => 1f + SkillMath.LinearBonus(GetEffectiveLevel(SkillId.Agility), config.AgilityJumpPerLevel.Value);

		public float AgilityAirControlMultiplier => 1f + SkillMath.LinearBonus(GetEffectiveLevel(SkillId.Agility), config.AgilityAirControlPerLevel.Value);

		public float AgilityJumpCostMultiplier => SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(SkillId.Agility), config.AgilityJumpEfficiencyPerLevel.Value);

		public float VitalityFallMultiplier => SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(SkillId.Vitality), config.VitalityFallReductionPerLevel.Value);

		public float WetGripPenaltyMultiplier => SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(SkillId.WetGrip), config.WetGripReductionPerLevel.Value);

		public float ClimbingTenacityPenaltyMultiplier => SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(SkillId.ClimbingTenacity), config.ClimbingTenacityReductionPerLevel.Value);

		public float VineMomentumRetention => Math.Min(0.75f, SkillMath.LinearBonus(GetEffectiveLevel(SkillId.VineClimbing), config.VineMomentumRetentionPerLevel.Value));

		public EffectService(UsageSkillsConfig config, ProgressionService progression, RunStateAdapter runState)
		{
			this.config = config;
			this.progression = progression;
			this.runState = runState;
		}

		public bool CanApply(Character? character)
		{
			if (config.EnableMod.Value && config.EnableEffects.Value && runState.IsGameplayScene && (Object)(object)character != (Object)null)
			{
				return (Object)(object)Character.localCharacter == (Object)(object)character;
			}
			return false;
		}

		public int GetEffectiveLevel(SkillId skillId)
		{
			int value = config.DebugAllSkillLevelOverride.Value;
			if (value >= 0)
			{
				return Math.Max(0, Math.Min(progression.MaximumLevel, value));
			}
			return progression.GetLevel(skillId);
		}

		public float ConditionGainMultiplier(SkillId skillId)
		{
			return SkillMath.AnchoredReductionMultiplier(GetEffectiveLevel(skillId), config.ConditionResistancePerLevel.Value);
		}

		public float ConditionRecoveryMultiplier(SkillId skillId)
		{
			return 1f + SkillMath.LinearBonus(GetEffectiveLevel(skillId), config.ConditionRecoveryPerLevel.Value);
		}
	}
}
namespace PEAKUsageSkills.Diagnostics
{
	internal sealed class DiagnosticHub
	{
		private readonly ManualLogSource log;

		private readonly UsageSkillsConfig config;

		private readonly RunStateAdapter runState;

		private readonly ProgressionService progression;

		private readonly EffectService effects;

		private readonly Dictionary<string, StatusAggregate> pendingStatuses = new Dictionary<string, StatusAggregate>(StringComparer.Ordinal);

		private float lastSnapshotTime;

		public RuntimeMetrics Metrics { get; } = new RuntimeMetrics();

		public DiagnosticHub(ManualLogSource log, UsageSkillsConfig config, RunStateAdapter runState, ProgressionService progression, EffectService effects)
		{
			this.log = log;
			this.config = config;
			this.runState = runState;
			this.progression = progression;
			this.effects = effects;
		}

		public void RecordAward(SkillId skillId, string source, double work, double experience)
		{
			SessionSkillMetrics skill = Metrics.GetSkill(skillId);
			skill.Work += work;
			skill.Experience += experience;
			skill.Awards++;
			skill.LastSource = source;
		}

		public void RecordRejected(SkillId skillId, string reason, double work)
		{
			SessionSkillMetrics skill = Metrics.GetSkill(skillId);
			skill.Rejections++;
			skill.LastRejection = reason;
		}

		public void RecordStaminaRequest(float raw, float effective, string source)
		{
			Metrics.RawStaminaRequest = raw;
			Metrics.EffectiveStaminaRequest = effective;
			Metrics.StaminaSource = source;
		}

		public void RecordWeight(float raw, float effective)
		{
			if (Math.Abs(Metrics.RawWeight - raw) >= 0.0001f || Math.Abs(Metrics.EffectiveWeight - effective) >= 0.0001f)
			{
				log.LogInfo((object)($"[UsageSkills:Weight] raw={raw:F4} effective={effective:F4} " + $"strengthMultiplier={effects.StrengthWeightMultiplier:F4}"));
			}
			Metrics.RawWeight = raw;
			Metrics.EffectiveWeight = effective;
		}

		public void RecordFall(float raw, float effective, string source)
		{
			Metrics.LastRawFallInjury = raw;
			Metrics.LastEffectiveFallInjury = effective;
			log.LogInfo((object)$"[UsageSkills:Fall] source={source} rawInjury={raw:F4} effectiveInjury={effective:F4} vitalityMultiplier={effects.VitalityFallMultiplier:F4}");
		}

		public void RecordStatusChange(string status, float requested, float actual, float latestValue, string source)
		{
			if (config.LogStatusChanges.Value && !(Math.Abs(actual) < 0.0001f))
			{
				string key = status + ":" + source;
				if (!pendingStatuses.TryGetValue(key, out StatusAggregate value))
				{
					value = new StatusAggregate();
					pendingStatuses.Add(key, value);
				}
				value.Events++;
				value.Requested += requested;
				value.Actual += actual;
				value.LatestValue = latestValue;
				value.LatestSource = source;
			}
		}

		public void RecordBar(float unitWidth, float backingWidth, float outlineWidth)
		{
			Metrics.StaminaUnitWidth = unitWidth;
			Metrics.StaminaBackingWidth = backingWidth;
			Metrics.StaminaOutlineWidth = outlineWidth;
		}

		public void RecordPatchHealth(string adapter, bool healthy, string hook)
		{
			string text = (healthy ? "Healthy" : "Missing");
			Metrics.PatchHealth[adapter] = text + " — " + hook;
			if (healthy)
			{
				log.LogInfo((object)("[UsageSkills:Patch] " + adapter + "=Healthy hook=" + hook));
			}
			else
			{
				log.LogError((object)("[UsageSkills:Patch] " + adapter + "=Missing hook=" + hook));
			}
		}

		public void RecordSave()
		{
			Metrics.SaveWrites++;
		}

		public void Tick()
		{
			if (config.AutomaticDiagnostics.Value)
			{
				float num = Math.Max(0.5f, config.DiagnosticIntervalSeconds.Value);
				if (!(Time.unscaledTime - lastSnapshotTime < num))
				{
					lastSnapshotTime = Time.unscaledTime;
					FlushStatusAggregates();
					LogSnapshot();
				}
			}
		}

		public string BuildOverlayText()
		{
			StringBuilder stringBuilder = new StringBuilder(1200);
			Character localCharacter = Character.localCharacter;
			stringBuilder.Append("Elin's PEAK").Append(' ').Append("0.4.7")
				.Append("-dev\n");
			stringBuilder.Append("Scene: ").Append(runState.ActiveSceneName).Append("  XP eligible: ")
				.Append(runState.IsExperienceEligible ? "YES" : "NO")
				.Append('\n');
			if ((Object)(object)localCharacter != (Object)null)
			{
				stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "Stamina: {0:F3} / {1:F3}  Extra: {2:F3}  Cost: {3:F4}->{4:F4} ({5})\n", localCharacter.data.currentStamina, localCharacter.GetMaxStamina(), localCharacter.data.extraStamina, Metrics.RawStaminaRequest, Metrics.EffectiveStaminaRequest, Metrics.StaminaSource);
				stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "Bar px: unit {0:F1}  backing {1:F1}  outline {2:F1}\n", Metrics.StaminaUnitWidth, Metrics.StaminaBackingWidth, Metrics.StaminaOutlineWidth);
				stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "Weight: {0:F3}->{1:F3}  Move: {2:F3}m  Wall/Rope/Vine +Y: {3:F3}/{4:F3}/{5:F3}m\n", Metrics.RawWeight, Metrics.EffectiveWeight, Metrics.LastPhysicalMovementDistance, Metrics.LastWallVerticalDelta, Metrics.LastRopeVerticalDelta, Metrics.LastVineVerticalDelta);
				stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "Fall injury: {0:F3}->{1:F3}  Grounded:{2} Sprint:{3} Wall:{4} Rope:{5} Vine:{6}\n", Metrics.LastRawFallInjury, Metrics.LastEffectiveFallInjury, localCharacter.data.isGrounded, localCharacter.data.isSprinting, localCharacter.data.isClimbing, localCharacter.data.isRopeClimbing, localCharacter.data.isVineClimbing);
				stringBuilder.Append("Statuses: ").Append(BuildStatusSummary(localCharacter)).Append('\n');
				stringBuilder.Append("Timed effects: ").Append(BuildAfflictionSummary(localCharacter)).Append('\n');
			}
			foreach (SkillId value in Enum.GetValues(typeof(SkillId)))
			{
				SessionSkillMetrics skill = Metrics.GetSkill(value);
				stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}: L{1} ({2:F1}/{3:F1})  work {4:F2}  XP +{5:F2}\n", value, effects.GetEffectiveLevel(value), progression.GetExperience(value), progression.GetExperienceToNextLevel(value), skill.Work, skill.Experience);
			}
			stringBuilder.Append("Patch health: ");
			stringBuilder.Append(string.Join(", ", Metrics.PatchHealth.Select<KeyValuePair<string, string>, string>((KeyValuePair<string, string> pair) => pair.Key + "=" + pair.Value.Split(' ')[0])));
			return stringBuilder.ToString();
		}

		private void FlushStatusAggregates()
		{
			foreach (KeyValuePair<string, StatusAggregate> pendingStatus in pendingStatuses)
			{
				StatusAggregate value = pendingStatus.Value;
				log.LogInfo((object)$"[UsageSkills:Status] key={pendingStatus.Key} events={value.Events} requested={value.Requested:F4} actual={value.Actual:F4} current={value.LatestValue:F4}");
			}
			pendingStatuses.Clear();
		}

		private void LogSnapshot()
		{
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				log.LogInfo((object)$"[UsageSkills:Snapshot] scene={runState.ActiveSceneName} xpEligible={runState.IsExperienceEligible} localCharacter=false");
				return;
			}
			log.LogInfo((object)($"[UsageSkills:Snapshot] scene={runState.ActiveSceneName} xpEligible={runState.IsExperienceEligible} " + $"stamina={localCharacter.data.currentStamina:F4}/{localCharacter.GetMaxStamina():F4} extra={localCharacter.data.extraStamina:F4} " + $"weight={Metrics.RawWeight:F4}->{Metrics.EffectiveWeight:F4} " + $"states=ground:{localCharacter.data.isGrounded},sprint:{localCharacter.data.isSprinting},wall:{localCharacter.data.isClimbing},rope:{localCharacter.data.isRopeClimbing},vine:{localCharacter.data.isVineClimbing} " + $"movement={Metrics.LastPhysicalMovementDistance:F4} wallDeltaY={Metrics.LastWallVerticalDelta:F4} " + $"ropeDeltaY={Metrics.LastRopeVerticalDelta:F4} vineDeltaY={Metrics.LastVineVerticalDelta:F4} " + "work=[" + BuildWorkSummary() + "] statuses=[" + BuildStatusSummary(localCharacter) + "] afflictions=[" + BuildAfflictionSummary(localCharacter) + "]"));
		}

		private string BuildWorkSummary()
		{
			List<string> list = new List<string>();
			foreach (SkillId value in Enum.GetValues(typeof(SkillId)))
			{
				SessionSkillMetrics skill = Metrics.GetSkill(value);
				if (skill.Awards > 0)
				{
					list.Add(value.ToString() + ":w=" + skill.Work.ToString("F3", CultureInfo.InvariantCulture) + ",xp=" + skill.Experience.ToString("F2", CultureInfo.InvariantCulture) + ",n=" + skill.Awards + ",src=" + skill.LastSource);
				}
			}
			if (list.Count != 0)
			{
				return string.Join(";", list);
			}
			return "none";
		}

		private static string BuildStatusSummary(Character character)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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)
			if (character.refs == null || (Object)(object)character.refs.afflictions == (Object)null)
			{
				return "unavailable";
			}
			List<string> list = new List<string>();
			foreach (STATUSTYPE value in Enum.GetValues(typeof(STATUSTYPE)))
			{
				float currentStatus = character.refs.afflictions.GetCurrentStatus(value);
				if (currentStatus > 0.0001f)
				{
					list.Add(((object)value/*cast due to .constrained prefix*/).ToString() + "=" + currentStatus.ToString("F3", CultureInfo.InvariantCulture));
				}
			}
			if (list.Count != 0)
			{
				return string.Join(",", list);
			}
			return "none";
		}

		private static string BuildAfflictionSummary(Character character)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (character.refs == null || (Object)(object)character.refs.afflictions == (Object)null || character.refs.afflictions.afflictionList == null)
			{
				return "unavailable";
			}
			List<string> list = new List<string>();
			foreach (Affliction affliction in character.refs.afflictions.afflictionList)
			{
				if (affliction != null)
				{
					list.Add(((object)affliction.GetAfflictionType()/*cast due to .constrained prefix*/).ToString() + "=" + affliction.timeElapsed.ToString("F1", CultureInfo.InvariantCulture) + "/" + affliction.totalTime.ToString("F1", CultureInfo.InvariantCulture));
				}
			}
			if (list.Count != 0)
			{
				return string.Join(",", list);
			}
			return "none";
		}
	}
	internal sealed class RuntimeMetrics
	{
		public float RawWeight { get; set; }

		public float EffectiveWeight { get; set; }

		public float RawStaminaRequest { get; set; }

		public float EffectiveStaminaRequest { get; set; }

		public string StaminaSource { get; set; } = "None";

		public float LastPhysicalMovementDistance { get; set; }

		public float LastWallVerticalDelta { get; set; }

		public float LastRopeVerticalDelta { get; set; }

		public float LastVineVerticalDelta { get; set; }

		public double SessionWallVerticalDistance { get; set; }

		public float LastRawFallInjury { get; set; }

		public float LastEffectiveFallInjury { get; set; }

		public float StaminaBackingWidth { get; set; }

		public float StaminaOutlineWidth { get; set; }

		public float StaminaUnitWidth { get; set; }

		public int SaveWrites { get; set; }

		public Dictionary<SkillId, SessionSkillMetrics> Skills { get; } = new Dictionary<SkillId, SessionSkillMetrics>();

		public Dictionary<string, string> PatchHealth { get; } = new Dictionary<string, string>(StringComparer.Ordinal);

		public SessionSkillMetrics GetSkill(SkillId skillId)
		{
			if (!Skills.TryGetValue(skillId, out SessionSkillMetrics value))
			{
				value = new SessionSkillMetrics();
				Skills.Add(skillId, value);
			}
			return value;
		}
	}
	internal sealed class SessionSkillMetrics
	{
		public double Work { get; set; }

		public double Experience { get; set; }

		public int Awards { get; set; }

		public int Rejections { get; set; }

		public string LastSource { get; set; } = "None";

		public string LastRejection { get; set; } = "None";
	}
	internal sealed class StatusAggregate
	{
		public int Events { get; set; }

		public float Requested { get; set; }

		public float Actual { get; set; }

		public float LatestValue { get; set; }

		public string LatestSource { get; set; } = string.Empty;
	}
}
namespace PEAKUsageSkills.Core
{
	internal sealed class ProgressionService
	{
		private readonly UsageSkillsConfig config;

		private readonly SaveStore store;

		private readonly ManualLogSource log;

		private readonly RunStateAdapter runState;

		private ProgressionSave save;

		private bool dirty;

		private float lastSaveTime;

		public int MaximumLevel => Math.Max(1, config.MaximumLevel.Value);

		public event Action<SkillId, int>? LevelChanged;

		public ProgressionService(UsageSkillsConfig config, SaveStore store, ManualLogSource log, RunStateAdapter runState)
		{
			this.config = config;
			this.store = store;
			this.log = log;
			this.runState = runState;
			save = store.Load();
			if (save.Skills.Remove("PackRat"))
			{
				dirty = true;
				log.LogInfo((object)"Removed retired Pack Rat progression from the local save.");
			}
			MergeLegacySkill("Resilience", SkillId.Vitality);
			MergeRetiredRecoverySkills();
			EnsureAllSkills();
		}

		public int GetLevel(SkillId skillId)
		{
			return GetState(skillId).Level;
		}

		public double GetExperience(SkillId skillId)
		{
			return GetState(skillId).Experience;
		}

		public double GetExperienceToNextLevel(SkillId skillId)
		{
			SkillSave state = GetState(skillId);
			if (state.Level < MaximumLevel)
			{
				return SkillMath.ExperienceToNextLevel(state.Level);
			}
			return 0.0;
		}

		public double GetLifetimeWork(SkillId skillId)
		{
			return GetState(skillId).LifetimeWork;
		}

		public bool AwardWork(SkillId skillId, double work, double experiencePerWork, string source)
		{
			if (!runState.IsExperienceEligible)
			{
				Plugin.Diagnostics?.RecordRejected(skillId, "IneligibleScene", work);
				return false;
			}
			if (work <= 0.0 || experiencePerWork <= 0.0 || double.IsNaN(work) || double.IsInfinity(work))
			{
				Plugin.Diagnostics?.RecordRejected(skillId, "NonPositiveWork", work);
				return false;
			}
			SkillSave state = GetState(skillId);
			if (state.Level >= MaximumLevel)
			{
				Plugin.Diagnostics?.RecordRejected(skillId, "MaximumLevel", work);
				return false;
			}
			double num = work * experiencePerWork;
			state.LifetimeWork += work;
			state.Experience += num;
			dirty = true;
			while (state.Level < MaximumLevel)
			{
				double num2 = SkillMath.ExperienceToNextLevel(state.Level);
				if (state.Experience + 1E-06 < num2)
				{
					break;
				}
				state.Experience -= num2;
				state.Level++;
				log.LogInfo((object)$"{skillId} increased to level {state.Level}.");
				this.LevelChanged?.Invoke(skillId, state.Level);
			}
			if (state.Level >= MaximumLevel)
			{
				state.Experience = 0.0;
			}
			Plugin.Diagnostics?.RecordAward(skillId, source, work, num);
			return true;
		}

		public void Tick()
		{
			if (dirty)
			{
				float num = Math.Max(5f, config.SaveIntervalSeconds.Value);
				if (Time.unscaledTime - lastSaveTime >= num)
				{
					Flush();
				}
			}
		}

		public void Flush()
		{
			if (!dirty)
			{
				return;
			}
			try
			{
				store.Save(save);
				lastSaveTime = Time.unscaledTime;
				dirty = false;
				Plugin.Diagnostics?.RecordSave();
			}
			catch (Exception arg)
			{
				log.LogError((object)$"Failed to save usage-skill progression: {arg}");
			}
		}

		private SkillSave GetState(SkillId skillId)
		{
			string key = skillId.ToString();
			if (!save.Skills.TryGetValue(key, out SkillSave value))
			{
				value = new SkillSave();
				save.Skills[key] = value;
				dirty = true;
			}
			value.Level = Math.Max(1, Math.Min(MaximumLevel, value.Level));
			value.Experience = Math.Max(0.0, value.Experience);
			value.LifetimeWork = Math.Max(0.0, value.LifetimeWork);
			return value;
		}

		private void EnsureAllSkills()
		{
			foreach (SkillId value in Enum.GetValues(typeof(SkillId)))
			{
				GetState(value);
			}
		}

		private void MergeRetiredRecoverySkills()
		{
			MergeLegacySkill("PoisonRecovery", SkillId.Toxicology);
			MergeLegacySkill("ColdRecovery", SkillId.ColdTolerance);
			MergeLegacySkill("HeatRecovery", SkillId.HeatTolerance);
			MergeLegacySkill("DrowsyRecovery", SkillId.DrowsyTolerance);
			MergeLegacySkill("SporeRecovery", SkillId.SporeTolerance);
		}

		private void MergeLegacySkill(string legacyKey, SkillId targetSkill)
		{
			if (save.Skills.TryGetValue(legacyKey, out SkillSave value))
			{
				SkillSave state = GetState(targetSkill);
				double total = TotalAccumulatedExperience(state) + TotalAccumulatedExperience(value);
				state.LifetimeWork = Math.Max(0.0, state.LifetimeWork) + Math.Max(0.0, value.LifetimeWork);
				SetFromTotalAccumulatedExperience(state, total);
				save.Skills.Remove(legacyKey);
				dirty = true;
				log.LogInfo((object)$"Merged legacy {legacyKey} progression into {targetSkill}.");
			}
		}

		private double TotalAccumulatedExperience(SkillSave state)
		{
			int num = Math.Max(1, Math.Min(MaximumLevel, state.Level));
			double num2 = Math.Max(0.0, state.Experience);
			for (int i = 1; i < num; i++)
			{
				num2 += SkillMath.ExperienceToNextLevel(i);
			}
			return num2;
		}

		private void SetFromTotalAccumulatedExperience(SkillSave state, double total)
		{
			state.Level = 1;
			state.Experience = Math.Max(0.0, total);
			while (state.Level < MaximumLevel)
			{
				double num = SkillMath.ExperienceToNextLevel(state.Level);
				if (state.Experience + 1E-06 < num)
				{
					break;
				}
				state.Experience -= num;
				state.Level++;
			}
			if (state.Level >= MaximumLevel)
			{
				state.Experience = 0.0;
			}
		}
	}
	public enum SkillId
	{
		Strength = 0,
		Endurance = 1,
		WallClimbing = 2,
		RopeClimbing = 3,
		VineClimbing = 4,
		Athletics = 5,
		Agility = 6,
		Vitality = 7,
		Toxicology = 8,
		ColdTolerance = 9,
		HeatTolerance = 10,
		DrowsyTolerance = 11,
		SporeTolerance = 12,
		HungerTolerance = 13,
		WetGrip = 15,
		ClimbingTenacity = 16,
		CurseTolerance = 22,
		PetrificationResistance = 23
	}
	public static class SkillMath
	{
		public const int DefaultMaximumLevel = 999;

		public static double ExperienceToNextLevel(int level)
		{
			int num = Math.Max(1, level);
			return Math.Round(100.0 * Math.Pow(num, 1.21), MidpointRounding.AwayFromZero);
		}

		public static float CappedLinearBonus(int level, float perLevel, float maximum)
		{
			if (level <= 0 || perLevel <= 0f || maximum <= 0f)
			{
				return 0f;
			}
			return Math.Min(maximum, (float)level * perLevel);
		}

		public static float LinearBonus(int level, float perLevel)
		{
			if (level <= 0 || perLevel <= 0f)
			{
				return 0f;
			}
			return (float)level * perLevel;
		}

		public static float ReciprocalBonusMultiplier(int level, float perLevel)
		{
			return 1f / (1f + LinearBonus(level, perLevel));
		}

		public static float AnchoredReductionMultiplier(int level, float perLevel, int anchorLevel = 500, int maximumLevel = 999, float terminalMultiplier = 0.001f)
		{
			if (level <= 0 || perLevel <= 0f)
			{
				return 1f;
			}
			int num = Math.Max(1, anchorLevel);
			int num2 = Math.Max(num + 1, maximumLevel);
			int num3 = Math.Min(level, num2);
			float num4 = num2;
			float num5 = 1f / (1f + num4 * perLevel);
			if (num3 <= num)
			{
				float num6 = (float)num3 * num4 / (float)num;
				return 1f / (1f + num6 * perLevel);
			}
			float num7 = Math.Max(1E-06f, Math.Min(num5, terminalMultiplier));
			double y = (double)(num3 - num) / (double)(num2 - num);
			return (float)((double)num5 * Math.Pow(num7 / num5, y));
		}

		public static float SizeDeltaForRenderedWidth(float currentSizeDelta, float currentRenderedWidth, float targetRenderedWidth)
		{
			return currentSizeDelta + targetRenderedWidth - currentRenderedWidth;
		}

		public static float ReductionMultiplier(int level, float perLevel, float maximumReduction)
		{
			return 1f - CappedLinearBonus(level, perLevel, maximumReduction);
		}

		public static int ExperienceProgressPercent(double experience, double required)
		{
			if (experience <= 0.0 || required <= 0.0 || double.IsNaN(experience) || double.IsInfinity(experience))
			{
				return 0;
			}
			double num = Math.Floor(experience / required * 100.0);
			return Math.Max(0, Math.Min(99, (int)num));
		}

		public static float ExpandedStaminaCapacity(float currentMaximum, float statusSum, float capacityBonus)
		{
			float num = Math.Max(1f - Math.Max(0f, statusSum), 0f);
			float num2 = Math.Max(1f + Math.Max(0f, capacityBonus) - Math.Max(0f, statusSum), 0f);
			return Math.Max(0f, currentMaximum + num2 - num);
		}

		public static int ExtraBackpackSlots(int strengthLevel)
		{
			if (strengthLevel >= 200)
			{
				return 5;
			}
			if (strengthLevel >= 120)
			{
				return 4;
			}
			if (strengthLevel >= 70)
			{
				return 3;
			}
			if (strengthLevel >= 40)
			{
				return 2;
			}
			if (strengthLevel >= 20)
			{
				return 1;
			}
			return 0;
		}

		public static double HungerMovementWork(float normalizedHunger, float distance, float threshold = 0.1f)
		{
			if (normalizedHunger < threshold || distance <= 0f)
			{
				return 0.0;
			}
			return (double)Math.Max(0f, normalizedHunger) * 100.0 * (double)distance;
		}
	}
}
namespace PEAKUsageSkills.Config
{
	internal sealed class UsageSkillsConfig
	{
		public ConfigEntry<bool> EnableMod { get; }

		public ConfigEntry<bool> EnableExperience { get; }

		public ConfigEntry<bool> EnableEffects { get; }

		public ConfigEntry<bool> EnableXpInCustomRuns { get; }

		public ConfigEntry<bool> ShowDebugOverlay { get; }

		public ConfigEntry<bool> ExtendStaminaBar { get; }

		public ConfigEntry<bool> AutomaticDiagnostics { get; }

		public ConfigEntry<float> DiagnosticIntervalSeconds { get; }

		public ConfigEntry<bool> LogStatusChanges { get; }

		public ConfigEntry<int> MaximumLevel { get; }

		public ConfigEntry<float> SaveIntervalSeconds { get; }

		public ConfigEntry<int> DebugAllSkillLevelOverride { get; }

		public ConfigEntry<float> EnduranceXpPerStamina { get; }

		public ConfigEntry<float> StrengthXpPerWork { get; }

		public ConfigEntry<float> WallClimbingXpPerMeter { get; }

		public ConfigEntry<float> RopeClimbingXpPerMeter { get; }

		public ConfigEntry<float> VineClimbingXpPerMeter { get; }

		public ConfigEntry<float> AthleticsXpPerMeter { get; }

		public ConfigEntry<float> AthleticsSprintXpPerMeter { get; }

		public ConfigEntry<float> AgilityXpPerJump { get; }

		public ConfigEntry<float> VitalityXpPerInjury { get; }

		public ConfigEntry<float> ConditionXpPerStatus { get; }

		public ConfigEntry<float> HungerMovementXpPerWork { get; }

		public ConfigEntry<float> WetGripXpPerMeter { get; }

		public ConfigEntry<float> ClimbingTenacityXpPerMeter { get; }

		public ConfigEntry<float> StrengthReductionPerLevel { get; }

		public ConfigEntry<float> MaximumStrengthReduction { get; }

		public ConfigEntry<float> EnduranceCapacityPerLevel { get; }

		public ConfigEntry<float> MaximumEnduranceCapacityBonus { get; }

		public ConfigEntry<float> EnduranceRegenPerLevel { get; }

		public ConfigEntry<float> MaximumEnduranceRegenBonus { get; }

		public ConfigEntry<float> EnduranceCostReductionPerLevel { get; }

		public ConfigEntry<float> MaximumEnduranceCostReduction { get; }

		public ConfigEntry<float> WallSpeedPerLevel { get; }

		public ConfigEntry<float> MaximumWallSpeedBonus { get; }

		public ConfigEntry<float> WallCostReductionPerLevel { get; }

		public ConfigEntry<float> MaximumWallCostReduction { get; }

		public ConfigEntry<float> RopeSpeedPerLevel { get; }

		public ConfigEntry<float> RopeCostEfficiencyPerLevel { get; }

		public ConfigEntry<float> VineSpeedPerLevel { get; }

		public ConfigEntry<float> VineCostEfficiencyPerLevel { get; }

		public ConfigEntry<float> VineMomentumRetentionPerLevel { get; }

		public ConfigEntry<float> AthleticsMovementPerLevel { get; }

		public ConfigEntry<float> AthleticsSprintMovementPerLevel { get; }

		public ConfigEntry<float> AthleticsSprintEfficiencyPerLevel { get; }

		public ConfigEntry<float> AgilityJumpPerLevel { get; }

		public ConfigEntry<float> AgilityAirControlPerLevel { get; }

		public ConfigEntry<float> AgilityJumpEfficiencyPerLevel { get; }

		public ConfigEntry<float> VitalityFallReductionPerLevel { get; }

		public ConfigEntry<float> ConditionResistancePerLevel { get; }

		public ConfigEntry<float> ConditionRecoveryPerLevel { get; }

		public ConfigEntry<float> HungerTrainingThreshold { get; }

		public ConfigEntry<float> WetGripReductionPerLevel { get; }

		public ConfigEntry<float> ClimbingTenacityReductionPerLevel { get; }

		public UsageSkillsConfig(ConfigFile config)
		{
			//IL_0bbc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc6: Expected O, but got Unknown
			//IL_0bd2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bdc: Expected O, but got Unknown
			//IL_0be8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bf2: Expected O, but got Unknown
			//IL_0bfe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c08: Expected O, but got Unknown
			//IL_0c14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c1e: Expected O, but got Unknown
			//IL_0c2a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c34: Expected O, but got Unknown
			//IL_0c40: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c4a: Expected O, but got Unknown
			//IL_0c56: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c60: Expected O, but got Unknown
			//IL_0c6c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c76: Expected O, but got Unknown
			EnableMod = config.Bind<bool>("General", "EnableMod", true, "Master switch for PEAK Usage Skills.");
			EnableExperience = config.Bind<bool>("General", "EnableExperience", true, "Allow eligible gameplay to grant usage-skill XP.");
			EnableEffects = config.Bind<bool>("General", "EnableEffects", true, "Apply gameplay effects from skill levels.");
			EnableXpInCustomRuns = config.Bind<bool>("General", "EnableXpInCustomRuns", false, "Allow XP in custom runs. Airport/lobby XP is always disabled.");
			ShowDebugOverlay = config.Bind<bool>("UI", "ShowDebugOverlay", false, "Show the compact diagnostics overlay. Also toggleable from the ESC menu.");
			ExtendStaminaBar = config.Bind<bool>("UI", "ExtendStaminaBar", true, "Extend stamina backing and outline for Endurance capacity above 100.");
			AutomaticDiagnostics = config.Bind<bool>("Diagnostics", "AutomaticDiagnostics", true, "Write automatic rate-limited gameplay diagnostics into the BepInEx log.");
			DiagnosticIntervalSeconds = config.Bind<float>("Diagnostics", "IntervalSeconds", 2f, "Interval for aggregate runtime snapshots.");
			LogStatusChanges = config.Bind<bool>("Diagnostics", "LogStatusChanges", true, "Aggregate and log status/affliction changes.");
			MaximumLevel = config.Bind<int>("Progression", "MaximumLevel", 999, "Shared local save/schema level maximum. This is not selected by a multiplayer host.");
			SaveIntervalSeconds = config.Bind<float>("Progression", "SaveIntervalSeconds", 30f, "Minimum interval between dirty progression saves.");
			DebugAllSkillLevelOverride = config.Bind<int>("Progression", "DebugAllSkillLevelOverride", -1, "-1 uses saved levels. Set 0..MaximumLevel to test effects without altering progression.");
			EnduranceXpPerStamina = config.Bind<float>("XP", "EnduranceXpPerStamina", 20f, "XP per normalized point of raw stamina requested (0.20 XP per displayed stamina point).");
			StrengthXpPerWork = config.Bind<float>("XP", "StrengthXpPerWork", 2f, "XP per raw Weight x movement meter.");
			WallClimbingXpPerMeter = config.Bind<float>("XP", "WallClimbingXpPerMeter", 8f, "XP per intentional wall-climbing meter in any direction.");
			RopeClimbingXpPerMeter = config.Bind<float>("XP", "RopeClimbingXpPerMeter", 8f, "XP per intentional rope-climbing meter in any direction.");
			VineClimbingXpPerMeter = config.Bind<float>("XP", "VineClimbingXpPerMeter", 8f, "XP per intentional vine-climbing meter in any direction.");
			AthleticsXpPerMeter = config.Bind<float>("XP", "AthleticsXpPerMeter", 0.22f, "XP per qualifying grounded walking meter.");
			AthleticsSprintXpPerMeter = config.Bind<float>("XP", "AthleticsSprintXpPerMeter", 0.9f, "XP per qualifying grounded sprinting meter.");
			AgilityXpPerJump = config.Bind<float>("XP", "AgilityXpPerJump", 8f, "XP per successfully executed local jump.");
			ConfigEntry<float> val = config.Bind<float>("XP", "ResilienceXpPerInjury", 100f, "Legacy Vitality XP setting retained only for 0.4.1 migration.");
			VitalityXpPerInjury = config.Bind<float>("XP", "VitalityXpPerInjury", 100f, "XP per normalized point of raw fall Injury.");
			ConditionXpPerStatus = config.Bind<float>("XP", "ConditionXpPerStatus", 100f, "XP per normalized point of actual incoming Resiliency affliction other than Hunger.");
			HungerMovementXpPerWork = config.Bind<float>("XP", "HungerMovementXpPerWork", 0.02f, "XP per displayed Hunger point x movement meter while Hunger is at least 10.");
			WetGripXpPerMeter = config.Bind<float>("XP", "WetGripXpPerMeter", 20f, "XP per slippery wall-climbing meter, weighted by current slipperiness.");
			ClimbingTenacityXpPerMeter = config.Bind<float>("XP", "ClimbingTenacityXpPerMeter", 40f, "XP per intentional wall-climbing meter while regular stamina is below 20%.");
			StrengthReductionPerLevel = config.Bind<float>("Effects", "StrengthWeightReductionPerLevel", 0.003f, "Anchored carry-Weight reduction rate per Strength level.");
			MaximumStrengthReduction = config.Bind<float>("Effects", "MaximumStrengthWeightReduction", 0.25f, "Legacy cap retained for configuration compatibility; linear level scaling does not use it.");
			EnduranceCapacityPerLevel = config.Bind<float>("Effects", "EnduranceCapacityPerLevel", 0.005f, "True base stamina capacity increase per Endurance level.");
			MaximumEnduranceCapacityBonus = config.Bind<float>("Effects", "MaximumEnduranceCapacityBonus", 0.15f, "Legacy cap retained for configuration compatibility; linear level scaling does not use it.");
			EnduranceRegenPerLevel = config.Bind<float>("Effects", "EnduranceRegenPerLevel", 0.001f, "Stamina regeneration increase per Endurance level.");
			MaximumEnduranceRegenBonus = config.Bind<float>("Effects", "MaximumEnduranceRegenBonus", 0.25f, "Legacy cap retained for configuration compatibility; linear level scaling does not use it.");
			EnduranceCostReductionPerLevel = config.Bind<float>("Effects", "EnduranceCostReductionPerLevel", 0f, "Legacy option. Endurance no longer reduces general stamina costs.");
			MaximumEnduranceCostReduction = config.Bind<float>("Effects", "MaximumEnduranceCostReduction", 0.1f, "Legacy cap retained for configuration compatibility; linear level scaling does not use it.");
			WallSpeedPerLevel = config.Bind<float>("Effects", "WallClimbingSpeedPerLevel", 0.003f, "Wall-climbing speed increase per level.");
			MaximumWallSpeedBonus = config.Bind<float>("Effects", "MaximumWallClimbingSpeedBonus", 0.15f, "Legacy cap retained for configuration compatibility; linear level scaling does not use it.");
			WallCostReductionPerLevel = config.Bind<float>("Effects", "WallClimbingCostReductionPerLevel", 0.003f, "Anchored wall-climbing stamina cost reduction rate per level.");
			MaximumWallCostReduction = config.Bind<float>("Effects", "MaximumWallClimbingCostReduction", 0.1f, "Legacy cap retained for configuration compatibility; linear level scaling does not use it.");
			RopeSpeedPerLevel = config.Bind<float>("Effects", "RopeClimbingSpeedPerLevel", 0.003f, "Rope-climbing speed increase per level.");
			RopeCostEfficiencyPerLevel = config.Bind<float>("Effects", "RopeClimbingCostEfficiencyPerLevel", 0.003f, "Anchored rope-climbing stamina cost reduction rate per level.");
			VineSpeedPerLevel = config.Bind<float>("Effects", "VineClimbingSpeedPerLevel", 0.003f, "Vine-climbing speed increase per level.");
			VineCostEfficiencyPerLevel = config.Bind<float>("Effects", "VineClimbingCostEfficiencyPerLevel", 0.003f, "Anchored vine-climbing stamina cost reduction rate per level.");
			VineMomentumRetentionPerLevel = config.Bind<float>("Effects", "VineMomentumRetentionPerLevel", 0.0005f, "Fraction of vine velocity damping removed per Vine Climbing level.");
			AthleticsMovementPerLevel = config.Bind<float>("Effects", "AthleticsMovementSpeedPerLevel", 0.001f, "Ground movement-force increase per Athletics level.");
			AthleticsSprintMovementPerLevel = config.Bind<float>("Effects", "AthleticsSprintSpeedPerLevel", 0.002f, "Additional sprint movement-force increase per Athletics level.");
			AthleticsSprintEfficiencyPerLevel = config.Bind<float>("Effects", "AthleticsSprintEfficiencyPerLevel", 0.003f, "Anchored sprint stamina cost reduction rate per Athletics level.");
			AgilityJumpPerLevel = config.Bind<float>("Effects", "AgilityJumpPerformancePerLevel", 0.0015f, "Jump impulse increase per Agility level.");
			AgilityAirControlPerLevel = config.Bind<float>("Effects", "AgilityAirControlPerLevel", 0.00025f, "Light airborne turning responsiveness increase per Agility level.");
			AgilityJumpEfficiencyPerLevel = config.Bind<float>("Effects", "AgilityJumpEfficiencyPerLevel", 0.003f, "Anchored jump stamina cost reduction rate per Agility level.");
			ConfigEntry<float> val2 = config.Bind<float>("Effects", "ResilienceFallReductionPerLevel", 0.003f, "Legacy Vitality effect setting retained only for 0.4.1 migration.");
			VitalityFallReductionPerLevel = config.Bind<float>("Effects", "VitalityFallReductionPerLevel", 0.003f, "Fall Injury reduction per Vitality level.");
			ConditionResistancePerLevel = config.Bind<float>("Effects", "ConditionResistancePerLevel", 0.0015f, "Anchored incoming-condition reduction rate per matching Resiliency level.");
			ConditionRecoveryPerLevel = config.Bind<float>("Effects", "ConditionRecoveryPerLevel", 0.0015f, "Natural condition-recovery increase per matching tolerance level.");
			HungerTrainingThreshold = config.Bind<float>("Effects", "HungerTrainingThreshold", 0.1f, "Normalized Hunger required before movement can train Hunger Tolerance.");
			WetGripReductionPerLevel = config.Bind<float>("Effects", "WetGripReductionPerLevel", 0.003f, "Anchored reduction rate for slippery downward pull and wind climbing drain.");
			ClimbingTenacityReductionPerLevel = config.Bind<float>("Effects", "ClimbingTenacityReductionPerLevel", 0.003f, "Anchored reduction rate for the below-20%-stamina climbing penalty.");
			ConfigEntry<int> val3 = config.Bind<int>("Internal", "ConfigSchema", 0, "Internal configuration migration marker.");
			if (val3.Value < 1)
			{
				if (MaximumLevel.Value == 50)
				{
					MaximumLevel.Value = 999;
				}
				val3.Value = 1;
				config.Save();
			}
			if (val3.Value < 2)
			{
				ShowDebugOverlay.Value = false;
				DebugAllSkillLevelOverride.Value = -1;
				MigrateExact(EnduranceXpPerStamina, 20f, 2f);
				MigrateExact(StrengthXpPerWork, 10f, 2f);
				MigrateExact(WallClimbingXpPerMeter, 8f, 2f);
				MigrateExact(RopeClimbingXpPerMeter, 8f, 2f);
				MigrateExact(VineClimbingXpPerMeter, 8f, 2f);
				MigrateExact(AthleticsXpPerMeter, 2f, 0.5f);
				MigrateExact(AgilityXpPerJump, 20f, 4f);
				MigrateExact(StrengthReductionPerLevel, 0.005f, 0.003f);
				MigrateExact(EnduranceCapacityPerLevel, 0.003f, 0.005f);
				MigrateExact(EnduranceRegenPerLevel, 0.005f, 0.001f);
				MigrateExact(EnduranceCostReductionPerLevel, 0.002f, 0f);
				MigrateExact(WallCostReductionPerLevel, 0.002f, 0.003f);
				MigrateExact(RopeCostEfficiencyPerLevel, 0.002f, 0.003f);
				MigrateExact(VineCostEfficiencyPerLevel, 0.002f, 0.003f);
				MigrateExact(AthleticsMovementPerLevel, 0.0015f, 0.001f);
				MigrateExact(AthleticsSprintEfficiencyPerLevel, 0.0015f, 0.003f);
				MigrateExact(AgilityJumpEfficiencyPerLevel, 0.0015f, 0.003f);
				MigrateExact(ConditionResistancePerLevel, 0.005f, 0.003f);
				MigrateExact(ConditionRecoveryPerLevel, 0.005f, 0.003f);
				val3.Value = 2;
				config.Save();
			}
			if (val3.Value < 3)
			{
				MigrateExact(AthleticsXpPerMeter, 0.5f, 0.35f);
				MigrateExact(AthleticsSprintXpPerMeter, 2f, 1.4f);
				val3.Value = 3;
				config.Save();
			}
			bool flag = val3.Value < 4;
			if (flag)
			{
				MigrateExact(EnduranceXpPerStamina, 2f, 6f);
				MigrateExact(WallClimbingXpPerMeter, 2f, 4f);
				MigrateExact(RopeClimbingXpPerMeter, 2f, 4f);
				MigrateExact(VineClimbingXpPerMeter, 2f, 4f);
				MigrateExact(AthleticsXpPerMeter, 0.35f, 0.28f);
				MigrateExact(AthleticsSprintXpPerMeter, 1.4f, 1.12f);
				MigrateExact(AgilityXpPerJump, 4f, 3.2f);
				MigrateExact(WetGripXpPerMeter, 2f, 6f);
				MigrateExact(ClimbingTenacityXpPerMeter, 2f, 6f);
				MigrateExact(ConditionResistancePerLevel, 0.003f, 0.0015f);
				MigrateExact(ConditionRecoveryPerLevel, 0.003f, 0.0015f);
				val3.Value = 4;
			}
			bool flag2 = val3.Value < 5;
			if (flag2)
			{
				VitalityXpPerInjury.Value = val.Value;
				VitalityFallReductionPerLevel.Value = val2.Value;
				val3.Value = 5;
			}
			bool flag3 = val3.Value < 6;
			if (flag3)
			{
				MigrateExact(EnduranceXpPerStamina, 6f, 10f);
				MigrateExact(WallClimbingXpPerMeter, 4f, 8f);
				MigrateExact(RopeClimbingXpPerMeter, 4f, 8f);
				MigrateExact(VineClimbingXpPerMeter, 4f, 8f);
				MigrateExact(AthleticsXpPerMeter, 0.28f, 0.22f);
				MigrateExact(AthleticsSprintXpPerMeter, 1.12f, 1.05f);
				MigrateExact(AgilityXpPerJump, 3.2f, 8f);
				MigrateExact(WetGripXpPerMeter, 6f, 20f);
				MigrateExact(ClimbingTenacityXpPerMeter, 6f, 40f);
				val3.Value = 6;
			}
			bool flag4 = val3.Value < 7;
			if (flag4)
			{
				MigrateExact(EnduranceXpPerStamina, 10f, 20f);
				MigrateExact(AthleticsSprintXpPerMeter, 1.05f, 0.9f);
				val3.Value = 7;
			}
			bool flag5 = val3.Value < 8;
			if (flag5)
			{
				MigrateExact(HungerMovementXpPerWork, 0.1f, 0.02f);
				MigrateExact(HungerTrainingThreshold, 0.3f, 0.1f);
				val3.Value = 8;
			}
			if ((0u | (config.Remove(new ConfigDefinition("XP", "ResilienceXpPerInjury")) ? 1u : 0u) | (config.Remove(new ConfigDefinition("Effects", "ResilienceFallReductionPerLevel")) ? 1u : 0u) | (config.Remove(new ConfigDefinition("Effects", "MaximumResilienceFallReduction")) ? 1u : 0u) | (config.Remove(new ConfigDefinition("XP", "ConditionRecoveryXpPerStatus")) ? 1u : 0u) | (config.Remove(new ConfigDefinition("XP", "PackRatXpPerWork")) ? 1u : 0u) | (config.Remove(new ConfigDefinition("Effects", "PackRatMitigationPerLevel")) ? 1u : 0u) | (config.Remove(new ConfigDefinition("Effects", "PackRatWeightPenaltyPerItem")) ? 1u : 0u) | (config.Remove(new ConfigDefinition("Effects", "PackRatMovementPenaltyPerItem")) ? 1u : 0u) | (config.Remove(new ConfigDefinition("Effects", "PackRatStaminaPenaltyPerItem")) ? 1u : 0u) | (flag ? 1u : 0u) | (flag2 ? 1u : 0u) | (flag3 ? 1u : 0u) | (flag4 ? 1u : 0u) | (flag5 ? 1u : 0u)) != 0)
			{
				config.Save();
			}
		}

		private static void MigrateExact(ConfigEntry<float> entry, float oldDefault, float newDefault)
		{
			if (Math.Abs(entry.Value - oldDefault) < 1E-06f)
			{
				entry.Value = newDefault;
			}
		}
	}
}