using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("StatManager")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("StatManager")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("179e1f3b-e093-4adf-9132-f04de1bfb69d")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace StatManager
{
	[BepInPlugin("Bocon.StatManager", "Stat Manager", "1.3.0")]
	public class StatManager : BaseUnityPlugin
	{
		private const string modGUID = "Bocon.StatManager";

		private const string modeName = "Stat Manager";

		private const string modVersion = "1.3.0";

		private readonly Harmony harmony = new Harmony("Bocon.StatManager");

		private static StatManager Instance;

		internal ManualLogSource mls;

		internal static ConfigEntry<int> HealthBonus;

		internal static ConfigEntry<int> SpeedBonus;

		internal static ConfigEntry<int> MapCountBonus;

		internal static ConfigEntry<int> EnergyBonus;

		internal static ConfigEntry<int> ExtraJumpBonus;

		internal static ConfigEntry<int> GrabRangeBonus;

		internal static ConfigEntry<int> GrabStrengthBonus;

		internal static ConfigEntry<int> TumbleLaunchBonus;

		internal static ConfigEntry<int> CrouchRestBonus;

		internal static ConfigEntry<int> TumbleWingsBonus;

		internal static ConfigEntry<int> TumbleClimbBonus;

		internal static ConfigEntry<int> DeathHeadBonus;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("Bocon.StatManager");
			mls.LogInfo((object)"Bocon.StatManager has loaded!");
			HealthBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Health", 10, "Amount of Health upgrades.");
			SpeedBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Sprint Speed", 5, "Amount of Sprint Speed upgrades.");
			MapCountBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Player Map Count", 1, "Amount of Player Map Count upgrades.");
			EnergyBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Energy", 10, "Amount of Energy upgrades.");
			ExtraJumpBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Extra Jump", 1, "Amount of Extra Jump upgrades.");
			GrabRangeBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Grab Range", 5, "Amount of Grab Range upgrades.");
			GrabStrengthBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Grab Strength", 5, "Amount of Grab Strength upgrades.");
			TumbleLaunchBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Tumble Launch", 5, "Amount of Tumble Launch upgrades.");
			CrouchRestBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Crouch Rest", 2, "Amount of Crouch rest upgrades.");
			TumbleWingsBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Tumble Wings", 2, "Amount of Tumble Wing upgrades.");
			TumbleClimbBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Tumble Climb", 1, "Enable Tumble Climb upgrade.");
			DeathHeadBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Death Head Battery", 1, "Enable Death Head Battery upgrade.");
			harmony.PatchAll();
		}
	}
}
namespace StatManager.Patches
{
	internal class Patch
	{
		[HarmonyPatch(typeof(GameDirector), "Start")]
		private class GameDirectorPatch
		{
			private static void Postfix()
			{
				Object.FindObjectOfType<MonoBehaviour>().StartCoroutine(WaitForLevel());
			}
		}

		[HarmonyPatch(typeof(RunManager), "ResetProgress")]
		private class RunManagerResetPatch
		{
			private static void Postfix()
			{
				hasAppliedUpgrade = false;
			}
		}

		[CompilerGenerated]
		private sealed class <WaitForLevel>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private List<PlayerAvatar>.Enumerator <>s__1;

			private PlayerAvatar <player>5__2;

			private string <steamId>5__3;

			private Dictionary<string, int> <upgrades>5__4;

			private int <healthToAdd>5__5;

			private int <speedToAdd>5__6;

			private int <mapCountToAdd>5__7;

			private int <energyToAdd>5__8;

			private int <extraJumpToAdd>5__9;

			private int <grabRangeToAdd>5__10;

			private int <grabStrengthToAdd>5__11;

			private int <tumbleLaunchToAdd>5__12;

			private int <crouchRestToAdd>5__13;

			private int <tumbleWingsToAdd>5__14;

			private int <tumbleClimbToAdd>5__15;

			private int <deathHeadToAdd>5__16;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = default(List<PlayerAvatar>.Enumerator);
				<player>5__2 = null;
				<steamId>5__3 = null;
				<upgrades>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!SemiFunc.LevelGenDone())
				{
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
				if (!hasAppliedUpgrade && SemiFunc.RunIsLevel() && SemiFunc.IsMasterClientOrSingleplayer())
				{
					<>s__1 = SemiFunc.PlayerGetAll().GetEnumerator();
					try
					{
						while (<>s__1.MoveNext())
						{
							<player>5__2 = <>s__1.Current;
							<steamId>5__3 = SemiFunc.PlayerGetSteamID(<player>5__2);
							<upgrades>5__4 = StatsManager.instance.FetchPlayerUpgrades(<steamId>5__3);
							<healthToAdd>5__5 = StatManager.HealthBonus.Value - (<upgrades>5__4.ContainsKey("Health") ? <upgrades>5__4["Health"] : 0);
							if (<healthToAdd>5__5 != 0)
							{
								PunManager.instance.UpgradePlayerHealth(<steamId>5__3, <healthToAdd>5__5);
							}
							<speedToAdd>5__6 = StatManager.SpeedBonus.Value - (<upgrades>5__4.ContainsKey("Speed") ? <upgrades>5__4["Speed"] : 0);
							if (<speedToAdd>5__6 != 0)
							{
								PunManager.instance.UpgradePlayerSprintSpeed(<steamId>5__3, <speedToAdd>5__6);
							}
							<mapCountToAdd>5__7 = StatManager.MapCountBonus.Value - (<upgrades>5__4.ContainsKey("Map Player Count") ? <upgrades>5__4["Map Player Count"] : 0);
							if (<mapCountToAdd>5__7 != 0)
							{
								PunManager.instance.UpgradeMapPlayerCount(<steamId>5__3, <mapCountToAdd>5__7);
							}
							<energyToAdd>5__8 = StatManager.EnergyBonus.Value - (<upgrades>5__4.ContainsKey("Stamina") ? <upgrades>5__4["Stamina"] : 0);
							if (<energyToAdd>5__8 != 0)
							{
								PunManager.instance.UpgradePlayerEnergy(<steamId>5__3, <energyToAdd>5__8);
							}
							<extraJumpToAdd>5__9 = StatManager.ExtraJumpBonus.Value - (<upgrades>5__4.ContainsKey("Extra Jump") ? <upgrades>5__4["Extra Jump"] : 0);
							if (<extraJumpToAdd>5__9 != 0)
							{
								PunManager.instance.UpgradePlayerExtraJump(<steamId>5__3, <extraJumpToAdd>5__9);
							}
							<grabRangeToAdd>5__10 = StatManager.GrabRangeBonus.Value - (<upgrades>5__4.ContainsKey("Range") ? <upgrades>5__4["Range"] : 0);
							if (<grabRangeToAdd>5__10 != 0)
							{
								PunManager.instance.UpgradePlayerGrabRange(<steamId>5__3, <grabRangeToAdd>5__10);
							}
							<grabStrengthToAdd>5__11 = StatManager.GrabStrengthBonus.Value - (<upgrades>5__4.ContainsKey("Strength") ? <upgrades>5__4["Strength"] : 0);
							if (<grabStrengthToAdd>5__11 != 0)
							{
								PunManager.instance.UpgradePlayerGrabStrength(<steamId>5__3, <grabStrengthToAdd>5__11);
							}
							<tumbleLaunchToAdd>5__12 = StatManager.TumbleLaunchBonus.Value - (<upgrades>5__4.ContainsKey("Launch") ? <upgrades>5__4["Launch"] : 0);
							if (<tumbleLaunchToAdd>5__12 != 0)
							{
								PunManager.instance.UpgradePlayerTumbleLaunch(<steamId>5__3, <tumbleLaunchToAdd>5__12);
							}
							<crouchRestToAdd>5__13 = StatManager.CrouchRestBonus.Value - (<upgrades>5__4.ContainsKey("Crouch Rest") ? <upgrades>5__4["Crouch Rest"] : 0);
							if (<crouchRestToAdd>5__13 != 0)
							{
								PunManager.instance.UpgradePlayerCrouchRest(<steamId>5__3, <crouchRestToAdd>5__13);
							}
							<tumbleWingsToAdd>5__14 = StatManager.TumbleWingsBonus.Value - (<upgrades>5__4.ContainsKey("Tumble Wings") ? <upgrades>5__4["Tumble Wings"] : 0);
							if (<tumbleWingsToAdd>5__14 != 0)
							{
								PunManager.instance.UpgradePlayerTumbleWings(<steamId>5__3, <tumbleWingsToAdd>5__14);
							}
							<tumbleClimbToAdd>5__15 = StatManager.TumbleClimbBonus.Value - (<upgrades>5__4.ContainsKey("Tumble Climb") ? <upgrades>5__4["Tumble Climb"] : 0);
							if (<tumbleClimbToAdd>5__15 != 0)
							{
								PunManager.instance.UpgradePlayerTumbleClimb(<steamId>5__3, <tumbleClimbToAdd>5__15);
							}
							<deathHeadToAdd>5__16 = StatManager.DeathHeadBonus.Value - (<upgrades>5__4.ContainsKey("Death Head") ? <upgrades>5__4["Death Head"] : 0);
							if (<deathHeadToAdd>5__16 != 0)
							{
								PunManager.instance.UpgradeDeathHeadBattery(<steamId>5__3, <deathHeadToAdd>5__16);
							}
							<steamId>5__3 = null;
							<upgrades>5__4 = null;
							<player>5__2 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__1).Dispose();
					}
					<>s__1 = default(List<PlayerAvatar>.Enumerator);
					hasAppliedUpgrade = true;
				}
				return false;
			}

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

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

		private static bool hasAppliedUpgrade;

		[IteratorStateMachine(typeof(<WaitForLevel>d__2))]
		private static IEnumerator WaitForLevel()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForLevel>d__2(0);
		}
	}
}