using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[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("PlayerScaling")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.4")]
[assembly: AssemblyInformationalVersion("1.2.4+194ad588f4355dafd402bbf7c37064017e0908d1")]
[assembly: AssemblyProduct("Player Scaling")]
[assembly: AssemblyTitle("PlayerScaling")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 PlayerScaling
{
	[HarmonyPatch(typeof(SemiFunc))]
	public static class DifficultyPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return Plugin.GetNumberedMethodInfos(typeof(SemiFunc), "RunGetDifficultyMultiplier", Array.Empty<Type>(), 10);
		}

		private static void Postfix(ref float __result)
		{
			float num = Plugin.PlayerScaling(ScalingType.Difficulty);
			if (num != 1f)
			{
				__result += Plugin.difficultyScalingOffset.Value;
				__result *= Mathf.Sqrt(num);
			}
		}
	}
	[HarmonyPatch(typeof(EnemyDirector))]
	[HarmonyPatch("AmountSetup")]
	public static class EnemyAmountPatch
	{
		private static void Prefix(ref int ___amountCurve1Value, ref int ___amountCurve2Value, ref int ___amountCurve3Value, EnemyDirector __instance)
		{
			float num = (float)RunManager.instance.levelsCompleted * Plugin.enemyScalingMultiplier.Value;
			float num2 = Mathf.FloorToInt(Mathf.Max(1f, Mathf.Min(2f, (num + 4f) / 5f)));
			float num3 = Mathf.FloorToInt(Mathf.Max(0f, Mathf.Min(2f, num / 3f)));
			float num4 = Mathf.FloorToInt(Mathf.Max(1f, Mathf.Min(2f, (num + 4f) / 5f)));
			float num5 = Mathf.Min(10f, 5f + num);
			float num6 = num2 / num5;
			float num7 = num3 / num5;
			float num8 = num4 / num5;
			float num9 = num6 + num7 + num8;
			float num10 = 1f;
			if (num9 > Plugin.maxEnemyDensity.Value)
			{
				num10 = Plugin.maxEnemyDensity.Value / num9;
			}
			if ((double)Plugin.maxEnemyDensity.Value > 0.8 && num > 11f)
			{
				num10 = (0.25f + 0.05f * num) / num9;
			}
			num6 *= num10;
			num7 *= num10;
			num8 *= num10;
			___amountCurve1Value = Mathf.Max(1, Mathf.RoundToInt(num6 * (float)Plugin.curModuleAmount));
			___amountCurve2Value = Mathf.Max(0, Mathf.RoundToInt(num7 * (float)Plugin.curModuleAmount));
			___amountCurve3Value = Mathf.Max(1, Mathf.RoundToInt(num8 * (float)Plugin.curModuleAmount));
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.StoresField(list[i], typeof(EnemyDirector).GetField("amountCurve1Value", BindingFlags.Instance | BindingFlags.NonPublic)))
				{
					num = i + 1;
				}
			}
			if (num > -1)
			{
				list.RemoveRange(0, num);
			}
			else
			{
				Plugin.Logger.LogError((object)"Cannot find <Stdfld amountCurve1Value> in EnemyDirector.AmountSetup");
			}
			return list.AsEnumerable();
		}
	}
	[BepInPlugin("dev.redfops.repo.playerscaling", "Player Scaling", "1.2.4")]
	public class Plugin : BaseUnityPlugin
	{
		public delegate float DifficultyDelegate();

		public const string modGUID = "dev.redfops.repo.playerscaling";

		public const string modName = "Player Scaling";

		public const string modVersion = "1.2.4";

		public static int curModuleAmount = 5;

		public static ConfigEntry<bool> mapScalingEnabled;

		public static ConfigEntry<bool> downScalingEnabled;

		public static ConfigEntry<bool> difficultyScalingEnabled;

		public static ConfigEntry<float> mapScalingMultiplier;

		public static ConfigEntry<float> enemyScalingMultiplier;

		public static ConfigEntry<float> valuableScalingMultiplier;

		public static ConfigEntry<float> difficultyScalingMultiplier;

		public static ConfigEntry<float> difficultyScalingOffset;

		public static ConfigEntry<int> defaultMaxMapSize;

		public static ConfigEntry<float> maxEnemyDensity;

		public static ConfigEntry<float> downScalingMin;

		public static ConfigEntry<float> globalScalingMultiplier;

		public static ConfigEntry<int> numPlayersStartScaling;

		public static ConfigEntry<float> playerDivisor;

		internal static ManualLogSource Logger;

		private readonly Harmony harmony = new Harmony("dev.redfops.repo.playerscaling");

		private void Awake()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Expected O, but got Unknown
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Expected O, but got Unknown
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			globalScalingMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("General Scaling", "Global Scaling Multiplier", 1f, new ConfigDescription("Multiplies player scaling by this number", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 10f), Array.Empty<object>()));
			numPlayersStartScaling = ((BaseUnityPlugin)this).Config.Bind<int>("General Scaling", "Player Scaling Minimum", 4, new ConfigDescription("Scaling only happens after the player count passes this number", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 16), Array.Empty<object>()));
			playerDivisor = ((BaseUnityPlugin)this).Config.Bind<float>("General Scaling", "Player Scaling Divisor", 4f, new ConfigDescription("Number of players divided by this is the scaling factor", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 12f), Array.Empty<object>()));
			downScalingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General Scaling", "Down Scaling Enabled", false, new ConfigDescription("Whether or not the map will be scaled down if less players than minimum", (AcceptableValueBase)null, Array.Empty<object>()));
			downScalingMin = ((BaseUnityPlugin)this).Config.Bind<float>("General Scaling", "Minimum Downscaling Multiplier", 0.5f, new ConfigDescription("The lowest the downscaling factor will go, not recommended below 0.5", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), Array.Empty<object>()));
			mapScalingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Map Scaling", "Map Scaling Enabled", true, new ConfigDescription("Whether or not the map will be scaled to the number of players", (AcceptableValueBase)null, Array.Empty<object>()));
			mapScalingMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Map Scaling", "Map Scaling Multiplier", 1f, new ConfigDescription("Multiplies the map size by this number (including max size)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 10f), Array.Empty<object>()));
			defaultMaxMapSize = ((BaseUnityPlugin)this).Config.Bind<int>("Map Scaling", "Default Max Map Size", 10, new ConfigDescription("Max map size before scaling", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 60), Array.Empty<object>()));
			enemyScalingMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies Scaling", "Enemies Scaling Multiplier", 1f, new ConfigDescription("Multiplies the number of enemies by this number (not including max)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 10f), Array.Empty<object>()));
			maxEnemyDensity = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies Scaling", "Max Enemy Density", 0.8f, new ConfigDescription("Caps number of enemies per map module", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 5f), Array.Empty<object>()));
			valuableScalingMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Valuables Scaling", "Valuables Scaling Multiplier", 1f, new ConfigDescription("Multiplies the amount of valuables by this number", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 10f), Array.Empty<object>()));
			difficultyScalingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Difficulty Scaling", "Difficulty Scaling Enabled", true, new ConfigDescription("Whether or not the difficulty will be scaled to the number of players", (AcceptableValueBase)null, Array.Empty<object>()));
			difficultyScalingMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Difficulty Scaling", "Difficulty Scaling Multiplier", 1f, new ConfigDescription("Multiplies the difficulty by this number", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 4f), Array.Empty<object>()));
			difficultyScalingOffset = ((BaseUnityPlugin)this).Config.Bind<float>("Difficulty Scaling", "Difficulty Scaling Offset", 0.085f, new ConfigDescription("Offsets the general difficulty", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			harmony.PatchAll(typeof(TileGenerationPatchTrans));
			harmony.PatchAll(typeof(TileGenerationPatch));
			harmony.PatchAll(typeof(DifficultyPatch));
			harmony.PatchAll(typeof(EnemyAmountPatch));
			harmony.PatchAll(typeof(ValuablePatch));
			Logger.LogInfo((object)"Plugin PlayerScaling is loaded!");
		}

		public static float PlayerScaling(ScalingType scalingType)
		{
			return scalingType switch
			{
				ScalingType.Valuable => valuableScalingMultiplier.Value, 
				ScalingType.Enemy => enemyScalingMultiplier.Value, 
				ScalingType.Map => mapScalingMultiplier.Value * (mapScalingEnabled.Value ? PlayerScaling(ScalingType.Global) : 1f), 
				ScalingType.Difficulty => difficultyScalingMultiplier.Value * (difficultyScalingEnabled.Value ? PlayerScaling(ScalingType.Global) : 1f), 
				_ => globalScalingMultiplier.Value * ((GameDirector.instance.PlayerList.Count < numPlayersStartScaling.Value || downScalingEnabled.Value) ? 1f : Mathf.Max((float)GameDirector.instance.PlayerList.Count / playerDivisor.Value, downScalingMin.Value)), 
			};
		}

		public static List<MethodBase> GetNumberedMethodInfos(Type source, string expectedBaseName, Type[] parameters, int checkMax, int checkMin = 0)
		{
			List<MethodBase> list = new List<MethodBase>();
			if (Traverse.Create(source).Method(expectedBaseName, parameters, (object[])null).MethodExists())
			{
				list.Add(AccessTools.Method(source, expectedBaseName, parameters, (Type[])null));
			}
			for (int i = checkMin; i < checkMax; i++)
			{
				if (Traverse.Create(source).Method(expectedBaseName + i, parameters, (object[])null).MethodExists())
				{
					list.Add(AccessTools.Method(source, expectedBaseName + i, parameters, (Type[])null));
				}
			}
			return list;
		}
	}
	public enum ScalingType
	{
		Global,
		Enemy,
		Map,
		Valuable,
		Difficulty
	}
	[HarmonyPatch(typeof(LevelGenerator))]
	[HarmonyPatch("TileGeneration")]
	public static class TileGenerationPatch
	{
		private static void Prefix(LevelGenerator __instance, ref int ___ModuleAmount, ref int ___ExtractionAmount, ref float ___DebugLevelSize)
		{
			float num = Plugin.PlayerScaling(ScalingType.Map);
			___ExtractionAmount = 0;
			if (___ModuleAmount > 4)
			{
				int num2 = Mathf.Min(Mathf.CeilToInt((float)Plugin.defaultMaxMapSize.Value * num), 2000);
				if (num2 > 200)
				{
					__instance.LevelHeight = 50;
					__instance.LevelWidth = 50;
				}
				___ModuleAmount = Mathf.Min((int)(num * (float)(5 + RunManager.instance.levelsCompleted)), num2);
				Plugin.curModuleAmount = ___ModuleAmount;
				___DebugLevelSize = num;
				___ExtractionAmount = (___ModuleAmount - 4) / 2;
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class TileGenerationPatchTrans
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			bool flag = false;
			int num = -1;
			int num2 = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (!CodeInstructionExtensions.StoresField(list[i], typeof(LevelGenerator).GetField("ModuleAmount", BindingFlags.Instance | BindingFlags.NonPublic)))
				{
					continue;
				}
				if (!flag)
				{
					flag = true;
					for (int num3 = i; num3 > 0; num3--)
					{
						if (list[num3].opcode == OpCodes.Ble)
						{
							num = num3 + 1;
							break;
						}
					}
				}
				else if (!(list[i - 1].opcode == OpCodes.Add))
				{
					num2 = i + 1;
					break;
				}
			}
			if (num > -1 && num2 > -1)
			{
				list.RemoveRange(num, num2 - num);
			}
			else
			{
				Plugin.Logger.LogError((object)"Cannot find <Stdfld ModuleAmount> in LevelGenerator.TileGeneration");
			}
			num = -1;
			num2 = -1;
			for (int j = 0; j < list.Count; j++)
			{
				if (CodeInstructionExtensions.StoresField(list[j], typeof(LevelGenerator).GetField("ExtractionAmount", BindingFlags.Instance | BindingFlags.NonPublic)) && list[j - 1].opcode == OpCodes.Ldc_I4_0)
				{
					num = j - 2;
					num2 = j + 1;
					break;
				}
			}
			if (num > -1 && num2 > -1)
			{
				list.RemoveRange(num, num2 - num);
			}
			else
			{
				Plugin.Logger.LogError((object)"Cannot find <Stdfld ExtractionAmount> in LevelGenerator.TileGeneration");
			}
			flag = false;
			num = -1;
			num2 = -1;
			for (int k = 0; k < list.Count; k++)
			{
				if (CodeInstructionExtensions.LoadsField(list[k], typeof(LevelGenerator).GetField("ModuleAmount", BindingFlags.Instance | BindingFlags.NonPublic), false) && !flag)
				{
					if (list[k + 1].opcode == OpCodes.Ldc_I4_S && (Convert.ToInt32(list[k + 1].operand) == 10 || Convert.ToInt32(list[k + 1].operand) == 15) && list[k + 2].opcode == OpCodes.Blt)
					{
						flag = true;
						num = k - 1;
					}
				}
				else if (flag && CodeInstructionExtensions.StoresField(list[k], typeof(LevelGenerator).GetField("ExtractionAmount", BindingFlags.Instance | BindingFlags.NonPublic)) && list[k - 1].opcode == OpCodes.Ldc_I4_0)
				{
					num2 = k + 1;
					break;
				}
			}
			if (num > -1 && num2 > -1)
			{
				list.RemoveRange(num, num2 - num);
			}
			else
			{
				Plugin.Logger.LogError((object)"Cannot find <Stdfld ExtractionAmount> in LevelGenerator.TileGeneration");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(ValuableDirector))]
	[HarmonyPatch("SetupHost")]
	[HarmonyWrapSafe]
	public static class ValuablePatch
	{
		private static AnimationCurve[] TotalMaxAmountCurves { get; set; }

		private static AnimationCurve[] TotalMaxValueCurves { get; set; }

		private static AnimationCurve[] TinyCurves { get; set; }

		private static AnimationCurve[] SmallCurves { get; set; }

		private static AnimationCurve[] MediumCurves { get; set; }

		private static AnimationCurve[] BigCurves { get; set; }

		private static AnimationCurve[] WideCurves { get; set; }

		private static AnimationCurve[] TallCurves { get; set; }

		private static AnimationCurve[] VeryTallCurves { get; set; }

		private static void Prefix(ValuableDirector __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			FieldRef<ValuableDirector, int> val = AccessTools.FieldRefAccess<ValuableDirector, int>("totalMaxAmount");
			Plugin.Logger.LogInfo((object)"Player scaling runs HERE");
			List<Plugin.DifficultyDelegate> staticNumberedMethodDelegates = GetStaticNumberedMethodDelegates<Plugin.DifficultyDelegate>(typeof(SemiFunc), "RunGetDifficultyMultiplier", Array.Empty<Type>(), 10);
			int num = Mathf.Min(10, 5 + RunManager.instance.levelsCompleted);
			if (RunManager.instance.levelsCompleted >= 10)
			{
				num += Mathf.Min(RunManager.instance.levelsCompleted - 9, 5);
			}
			float mapScalingFactor = (float)Plugin.curModuleAmount / (float)num;
			mapScalingFactor *= Plugin.valuableScalingMultiplier.Value;
			List<FieldRef<ValuableDirector, AnimationCurve>> numberedFieldRefs = GetNumberedFieldRefs<ValuableDirector, AnimationCurve>(__instance, "totalMaxAmountCurve", 10);
			if (numberedFieldRefs.Count != 0)
			{
				if (TotalMaxAmountCurves == null)
				{
					TotalMaxAmountCurves = (AnimationCurve[])(object)new AnimationCurve[numberedFieldRefs.Count];
				}
				foreach (Tuple<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> item in (from tuple in numberedFieldRefs.Zip(staticNumberedMethodDelegates, Tuple.Create<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>)
					where tuple.Item1 != null && tuple.Item2 != null
					select tuple).Select((Tuple<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> value, int index) => Tuple.Create<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>(index, value.Item1, value.Item2)))
				{
					item.Item2.Invoke(__instance) = ReplaceCurve(ref TotalMaxAmountCurves[item.Item1], item.Item2.Invoke(__instance), (float value) => value * mapScalingFactor);
				}
			}
			else
			{
				val.Invoke(__instance) = (int)Math.Ceiling((float)val.Invoke(__instance) * mapScalingFactor);
			}
			List<FieldRef<ValuableDirector, AnimationCurve>> numberedFieldRefs2 = GetNumberedFieldRefs<ValuableDirector, AnimationCurve>(__instance, "totalMaxValueCurve", 10);
			if (numberedFieldRefs2.Count != 0)
			{
				if (TotalMaxValueCurves == null)
				{
					TotalMaxValueCurves = (AnimationCurve[])(object)new AnimationCurve[numberedFieldRefs2.Count];
				}
				foreach (Tuple<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> item2 in from value in numberedFieldRefs2.Zip(staticNumberedMethodDelegates, Tuple.Create<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>).Select((Tuple<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> value, int index) => Tuple.Create<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>(index, value.Item1, value.Item2))
					where value.Item2 != null && value.Item3 != null
					select value)
				{
					item2.Item2.Invoke(__instance) = ReplaceCurve(ref TotalMaxValueCurves[item2.Item1], item2.Item2.Invoke(__instance), (float value) => value * mapScalingFactor);
				}
			}
			List<FieldRef<ValuableDirector, AnimationCurve>> numberedFieldRefs3 = GetNumberedFieldRefs<ValuableDirector, AnimationCurve>(__instance, "tinyMaxAmountCurve", 10);
			if (TinyCurves == null)
			{
				TinyCurves = (AnimationCurve[])(object)new AnimationCurve[numberedFieldRefs3.Count];
			}
			foreach (Tuple<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> item3 in from value in numberedFieldRefs3.Zip(staticNumberedMethodDelegates, Tuple.Create<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>).Select((Tuple<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> value, int index) => Tuple.Create<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>(index, value.Item1, value.Item2))
				where value.Item2 != null && value.Item3 != null
				select value)
			{
				item3.Item2.Invoke(__instance) = ReplaceCurve(ref TinyCurves[item3.Item1], item3.Item2.Invoke(__instance), (float value) => value * mapScalingFactor);
			}
			List<FieldRef<ValuableDirector, AnimationCurve>> numberedFieldRefs4 = GetNumberedFieldRefs<ValuableDirector, AnimationCurve>(__instance, "smallMaxAmountCurve", 10);
			if (SmallCurves == null)
			{
				SmallCurves = (AnimationCurve[])(object)new AnimationCurve[numberedFieldRefs4.Count];
			}
			foreach (Tuple<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> item4 in from value in numberedFieldRefs4.Zip(staticNumberedMethodDelegates, Tuple.Create<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>).Select((Tuple<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> value, int index) => Tuple.Create<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>(index, value.Item1, value.Item2))
				where value.Item2 != null && value.Item3 != null
				select value)
			{
				item4.Item2.Invoke(__instance) = ReplaceCurve(ref SmallCurves[item4.Item1], item4.Item2.Invoke(__instance), (float value) => value * mapScalingFactor);
			}
			List<FieldRef<ValuableDirector, AnimationCurve>> numberedFieldRefs5 = GetNumberedFieldRefs<ValuableDirector, AnimationCurve>(__instance, "mediumMaxAmountCurve", 10);
			if (MediumCurves == null)
			{
				MediumCurves = (AnimationCurve[])(object)new AnimationCurve[numberedFieldRefs5.Count];
			}
			foreach (Tuple<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> item5 in from value in numberedFieldRefs5.Zip(staticNumberedMethodDelegates, Tuple.Create<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>).Select((Tuple<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> value, int index) => Tuple.Create<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>(index, value.Item1, value.Item2))
				where value.Item2 != null && value.Item3 != null
				select value)
			{
				item5.Item2.Invoke(__instance) = ReplaceCurve(ref MediumCurves[item5.Item1], item5.Item2.Invoke(__instance), (float value) => value * mapScalingFactor);
			}
			List<FieldRef<ValuableDirector, AnimationCurve>> numberedFieldRefs6 = GetNumberedFieldRefs<ValuableDirector, AnimationCurve>(__instance, "bigMaxAmountCurve", 10);
			if (BigCurves == null)
			{
				BigCurves = (AnimationCurve[])(object)new AnimationCurve[numberedFieldRefs6.Count];
			}
			foreach (Tuple<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> item6 in from value in numberedFieldRefs6.Zip(staticNumberedMethodDelegates, Tuple.Create<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>).Select((Tuple<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> value, int index) => Tuple.Create<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>(index, value.Item1, value.Item2))
				where value.Item2 != null && value.Item3 != null
				select value)
			{
				item6.Item2.Invoke(__instance) = ReplaceCurve(ref BigCurves[item6.Item1], item6.Item2.Invoke(__instance), (float value) => value * mapScalingFactor);
			}
			List<FieldRef<ValuableDirector, AnimationCurve>> numberedFieldRefs7 = GetNumberedFieldRefs<ValuableDirector, AnimationCurve>(__instance, "wideMaxAmountCurve", 10);
			if (WideCurves == null)
			{
				WideCurves = (AnimationCurve[])(object)new AnimationCurve[numberedFieldRefs7.Count];
			}
			foreach (Tuple<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> item7 in from value in numberedFieldRefs7.Zip(staticNumberedMethodDelegates, Tuple.Create<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>).Select((Tuple<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> value, int index) => Tuple.Create<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>(index, value.Item1, value.Item2))
				where value.Item2 != null && value.Item3 != null
				select value)
			{
				item7.Item2.Invoke(__instance) = ReplaceCurve(ref WideCurves[item7.Item1], item7.Item2.Invoke(__instance), (float value) => value * mapScalingFactor);
			}
			List<FieldRef<ValuableDirector, AnimationCurve>> numberedFieldRefs8 = GetNumberedFieldRefs<ValuableDirector, AnimationCurve>(__instance, "tallMaxAmountCurve", 10);
			if (TallCurves == null)
			{
				TallCurves = (AnimationCurve[])(object)new AnimationCurve[numberedFieldRefs8.Count];
			}
			foreach (Tuple<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> item8 in from value in numberedFieldRefs8.Zip(staticNumberedMethodDelegates, Tuple.Create<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>).Select((Tuple<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> value, int index) => Tuple.Create<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>(index, value.Item1, value.Item2))
				where value.Item2 != null && value.Item3 != null
				select value)
			{
				item8.Item2.Invoke(__instance) = ReplaceCurve(ref TallCurves[item8.Item1], item8.Item2.Invoke(__instance), (float value) => value * mapScalingFactor);
			}
			List<FieldRef<ValuableDirector, AnimationCurve>> numberedFieldRefs9 = GetNumberedFieldRefs<ValuableDirector, AnimationCurve>(__instance, "veryTallMaxAmountCurve", 10);
			if (VeryTallCurves == null)
			{
				VeryTallCurves = (AnimationCurve[])(object)new AnimationCurve[numberedFieldRefs9.Count];
			}
			foreach (Tuple<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> item9 in from value in numberedFieldRefs9.Zip(staticNumberedMethodDelegates, Tuple.Create<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>).Select((Tuple<FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate> value, int index) => Tuple.Create<int, FieldRef<ValuableDirector, AnimationCurve>, Plugin.DifficultyDelegate>(index, value.Item1, value.Item2))
				where value.Item2 != null && value.Item3 != null
				select value)
			{
				item9.Item2.Invoke(__instance) = ReplaceCurve(ref VeryTallCurves[item9.Item1], item9.Item2.Invoke(__instance), (float value) => value * mapScalingFactor);
			}
		}

		private static AnimationCurve ReplaceCurve(ref AnimationCurve target, AnimationCurve source, Func<float, float> calculate)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0061: 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_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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogInfo((object)("Player scaling will replace a curve with a factor of " + calculate(1f)));
			if (target == source)
			{
				return target;
			}
			target = new AnimationCurve();
			Plugin.Logger.LogInfo((object)"Player scaling will copy a curve for scaling");
			target.CopyFrom(source);
			target.ClearKeys();
			Keyframe[] keys = source.GetKeys();
			for (int i = 0; i < keys.Length; i++)
			{
				Keyframe val = keys[i];
				Keyframe val2 = val;
				((Keyframe)(ref val2)).value = calculate(((Keyframe)(ref val)).value);
				Keyframe val3 = val2;
				target.AddKey(val3);
			}
			return target;
		}

		private static List<FieldRef<S, T>> GetNumberedFieldRefs<S, T>(S source, string expectedBaseName, int checkMax, int checkMin = 0)
		{
			List<FieldRef<S, T>> list = new List<FieldRef<S, T>>();
			if (Traverse.Create((object)source).Field(expectedBaseName).FieldExists())
			{
				list.Add(AccessTools.FieldRefAccess<S, T>(expectedBaseName));
			}
			for (int i = checkMin; i < checkMax; i++)
			{
				if (Traverse.Create((object)source).Field(expectedBaseName + i).FieldExists())
				{
					list.Add(AccessTools.FieldRefAccess<S, T>(expectedBaseName + i));
				}
			}
			return list;
		}

		private static List<T> GetStaticNumberedMethodDelegates<T>(Type source, string expectedBaseName, Type[] parameters, int checkMax, int checkMin = 0) where T : Delegate
		{
			List<T> list = new List<T>();
			if (Traverse.Create(source).Method(expectedBaseName, parameters, (object[])null).MethodExists())
			{
				list.Add(AccessTools.MethodDelegate<T>(AccessTools.Method(source, expectedBaseName, parameters, (Type[])null), (object)source, true));
			}
			for (int i = checkMin; i < checkMax; i++)
			{
				if (Traverse.Create(source).Method(expectedBaseName + i, parameters, (object[])null).MethodExists())
				{
					list.Add(AccessTools.MethodDelegate<T>(AccessTools.Method(source, expectedBaseName + i, parameters, (Type[])null), (object)source, true));
				}
			}
			return list;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "PlayerScaling";

		public const string PLUGIN_NAME = "Player Scaling";

		public const string PLUGIN_VERSION = "1.2.4";
	}
}