using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using MauriceBaller.Cheats;
using MauriceBridge;
using Microsoft.CodeAnalysis;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using PluginConfig.API.Functionals;
using TMPro;
using ULTRAKILL.Enemy;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("bitmotte.MauriceBaller")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+46555565b2b8c1061a034061308747df11d3eb91")]
[assembly: AssemblyProduct("Maurice Baller")]
[assembly: AssemblyTitle("bitmotte.MauriceBaller")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.0.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;
		}
	}
}
public class BallerLeg : MonoBehaviour
{
	private bool goodToGo = false;

	public Transform joint1;

	public Transform joint2;

	public Transform joint3;

	public LineRenderer legRenderer;

	private void Awake()
	{
		joint1 = ((Component)this).transform.GetChild(0);
		joint2 = ((Component)this).transform.GetChild(1);
		joint3 = ((Component)this).transform.GetChild(2);
		((Component)((Component)this).transform.GetChild(3)).gameObject.TryGetComponent<LineRenderer>(ref legRenderer);
		if ((Object)(object)legRenderer == (Object)null)
		{
			legRenderer = ((Component)((Component)this).transform.GetChild(3)).gameObject.AddComponent<LineRenderer>();
		}
		legRenderer.positionCount = 3;
		goodToGo = true;
	}

	private void Update()
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: 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_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		if (goodToGo)
		{
			legRenderer.SetPositions((Vector3[])(object)new Vector3[3] { joint1.position, joint2.position, joint3.position });
		}
	}
}
namespace MauriceBaller
{
	public static class GlobalConfig
	{
		public static bool bestiaryAlreadyAdded = false;

		public static bool sandboxItemAlreadyAdded = false;

		public static Dictionary<string, bool> breakers = new Dictionary<string, bool>();

		public static bool gravity = true;

		public static float gravityScale = 1f;

		public static float gravityScaleVariance = 0.5f;

		public static float bounciness = 0.5f;

		public static float bouncinessVariance = 0.3f;

		public static bool legs = true;

		public static bool variantJingle = true;

		public static float variantChance = 1f;

		public static Dictionary<string, float> individualVariantChances = new Dictionary<string, float>();

		public static float totalVariantChances;

		public static void InitGlobalConfig()
		{
			InitBreakers();
			InitIndividualVariantChances();
		}

		private static void InitBreakers()
		{
			breakers.Add("ground slam", value: true);
			breakers.Add("heavypunch", value: false);
			breakers.Add("punch", value: false);
			breakers.Add("explosion", value: false);
			breakers.Add("zap", value: true);
			breakers.Add("projectile", value: false);
			breakers.Add("environment", value: true);
			breakers.Add("acid", value: true);
			breakers.Add("fire", value: false);
			breakers.Add("revolver", value: false);
			breakers.Add("shotgun", value: false);
			breakers.Add("shotgunzone", value: false);
			breakers.Add("chainsawzone", value: false);
			breakers.Add("chainsaw", value: false);
			breakers.Add("chainsawprojectile", value: false);
			breakers.Add("hammer", value: false);
			breakers.Add("nail", value: false);
			breakers.Add("harpoon", value: true);
			breakers.Add("zapper", value: false);
			breakers.Add("aftershock", value: false);
			breakers.Add("sawblade", value: true);
			breakers.Add("railcannon", value: false);
			breakers.Add("drill", value: false);
			breakers.Add("drillpunch", value: false);
			breakers.Add("cannonball", value: false);
			breakers.Add("shotgun0", value: false);
			breakers.Add("rocket0", value: false);
			breakers.Add("enemy", value: false);
		}

		private static void InitIndividualVariantChances()
		{
			individualVariantChances.Add("plushie", 1f);
			individualVariantChances.Add("gold", 1f);
			individualVariantChances.Add("eye", 1f);
			individualVariantChances.Add("loss", 1f);
			individualVariantChances.Add("evil_mean_green", 1f);
			individualVariantChances.Add("big", 1f);
			individualVariantChances.Add("virtue", 1f);
			individualVariantChances.Add("maurfire", 1f);
			individualVariantChances.Add("looker", 1f);
			individualVariantChances.Add("false_virtue", 1f);
			individualVariantChances.Add("ballrice", 1f);
			individualVariantChances.Add("moai", 1f);
			individualVariantChances.Add("baller_block_man", 1f);
		}

		public static void CleanCorpses()
		{
			GameObject[] allCorpses = SceneUtility.allCorpses;
			foreach (GameObject val in allCorpses)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
			SceneUtility.allCorpses = Array.Empty<GameObject>();
		}
	}
	public static class MauriceConfigurator
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static PostConfigChangeEvent <0>__UpdateGlobalConfig;

			public static OnClick <1>__OpenDiscord;

			public static OnClick <2>__CleanCorpses;

			public static OnClick <3>__EnableAllVariants;

			public static OnClick <4>__DisableAllVariants;

			public static OnClick <5>__ResetAllVariants;

			public static OnClick <6>__ResetAllBreakers;

			public static OnClick <7>__EnableAllBreakers;

			public static OnClick <8>__DisableAllBreakers;
		}

		public static ButtonField clean;

		public static ButtonField resetBreakers;

		public static ButtonField enableAllBreakers;

		public static ButtonField disableAllBreakers;

		public static BoolField groundSlamBreaker;

		public static BoolField heavypunchBreaker;

		public static BoolField punchBreaker;

		public static BoolField explosionBreaker;

		public static BoolField zapBreaker;

		public static BoolField projectileBreaker;

		public static BoolField environmentBreaker;

		public static BoolField acidBreaker;

		public static BoolField fireBreaker;

		public static BoolField revolverBreaker;

		public static BoolField shotgunBreaker;

		public static BoolField shotgunzoneBreaker;

		public static BoolField chainsawzoneBreaker;

		public static BoolField chainsawBreaker;

		public static BoolField chainsawprojectileBreaker;

		public static BoolField hammerBreaker;

		public static BoolField nailBreaker;

		public static BoolField harpoonBreaker;

		public static BoolField zapperBreaker;

		public static BoolField aftershockBreaker;

		public static BoolField sawbladeBreaker;

		public static BoolField railcannonBreaker;

		public static BoolField drillBreaker;

		public static BoolField drillpunchBreaker;

		public static BoolField cannonballBreaker;

		public static BoolField shotgun0Breaker;

		public static BoolField rocket0Breaker;

		public static BoolField enemyBreaker;

		public static BoolField gravity;

		public static FloatSliderField gravityScale;

		public static FloatSliderField gravityScaleVariance;

		public static FloatSliderField bounciness;

		public static FloatSliderField bouncinessVariance;

		public static BoolField legs;

		public static BoolField variantJingle;

		public static FloatSliderField variantChance;

		public static ButtonField resetVariants;

		public static ButtonField maxOutAllVariants;

		public static ButtonField disableAllVariants;

		public static FloatSliderField plushieChance;

		public static FloatSliderField goldChance;

		public static FloatSliderField eyeChance;

		public static FloatSliderField lossChance;

		public static FloatSliderField evilMeanGreenChance;

		public static FloatSliderField bigChance;

		public static FloatSliderField virtueChance;

		public static FloatSliderField maurfireChance;

		public static FloatSliderField lookerChance;

		public static FloatSliderField falseVirtueChance;

		public static FloatSliderField ballriceChance;

		public static FloatSliderField moaiChance;

		public static FloatSliderField ballerBlockManChance;

		public static ButtonField joinDC;

		public static PluginConfigurator CreateConfigurator()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Expected O, but got Unknown
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Expected O, but got Unknown
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Expected O, but got Unknown
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Expected O, but got Unknown
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Expected O, but got Unknown
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Expected O, but got Unknown
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Expected O, but got Unknown
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Expected O, but got Unknown
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Expected O, but got Unknown
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Expected O, but got Unknown
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Expected O, but got Unknown
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Expected O, but got Unknown
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Expected O, but got Unknown
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Expected O, but got Unknown
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Expected O, but got Unknown
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Expected O, but got Unknown
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Expected O, but got Unknown
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Expected O, but got Unknown
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Expected O, but got Unknown
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Expected O, but got Unknown
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Expected O, but got Unknown
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Expected O, but got Unknown
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Expected O, but got Unknown
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Expected O, but got Unknown
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Expected O, but got Unknown
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Expected O, but got Unknown
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Expected O, but got Unknown
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Expected O, but got Unknown
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ad: Expected O, but got Unknown
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Expected O, but got Unknown
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ed: Expected O, but got Unknown
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Expected O, but got Unknown
			//IL_0513: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Expected O, but got Unknown
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Expected O, but got Unknown
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_054c: Expected O, but got Unknown
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0567: Expected O, but got Unknown
			//IL_058b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0595: Expected O, but got Unknown
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ac: Expected O, but got Unknown
			//IL_05b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ba: Expected O, but got Unknown
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d0: Expected O, but got Unknown
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e6: Expected O, but got Unknown
			//IL_05f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fc: Expected O, but got Unknown
			//IL_0603: Unknown result type (might be due to invalid IL or missing references)
			//IL_060a: Expected O, but got Unknown
			//IL_062a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0634: Expected O, but got Unknown
			//IL_0642: Unknown result type (might be due to invalid IL or missing references)
			//IL_0649: Expected O, but got Unknown
			//IL_0669: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Expected O, but got Unknown
			//IL_0681: Unknown result type (might be due to invalid IL or missing references)
			//IL_0688: Expected O, but got Unknown
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b2: Expected O, but got Unknown
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c7: Expected O, but got Unknown
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f1: Expected O, but got Unknown
			//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0706: Expected O, but got Unknown
			//IL_0726: Unknown result type (might be due to invalid IL or missing references)
			//IL_0730: Expected O, but got Unknown
			//IL_073e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0745: Expected O, but got Unknown
			//IL_0765: Unknown result type (might be due to invalid IL or missing references)
			//IL_076f: Expected O, but got Unknown
			//IL_077d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0784: Expected O, but got Unknown
			//IL_07a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ae: Expected O, but got Unknown
			//IL_07bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c3: Expected O, but got Unknown
			//IL_07e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ed: Expected O, but got Unknown
			//IL_07fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0802: Expected O, but got Unknown
			//IL_0822: Unknown result type (might be due to invalid IL or missing references)
			//IL_082c: Expected O, but got Unknown
			//IL_083a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0841: Expected O, but got Unknown
			//IL_0861: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Expected O, but got Unknown
			//IL_0879: Unknown result type (might be due to invalid IL or missing references)
			//IL_0880: Expected O, but got Unknown
			//IL_08a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_08aa: Expected O, but got Unknown
			//IL_08b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bf: Expected O, but got Unknown
			//IL_08df: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e9: Expected O, but got Unknown
			//IL_08f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fe: Expected O, but got Unknown
			//IL_091e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0928: Expected O, but got Unknown
			//IL_0936: Unknown result type (might be due to invalid IL or missing references)
			//IL_093d: Expected O, but got Unknown
			//IL_0948: Unknown result type (might be due to invalid IL or missing references)
			//IL_094f: Expected O, but got Unknown
			//IL_0961: Unknown result type (might be due to invalid IL or missing references)
			//IL_0968: Expected O, but got Unknown
			//IL_0973: Unknown result type (might be due to invalid IL or missing references)
			//IL_097a: Expected O, but got Unknown
			//IL_098c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0993: Expected O, but got Unknown
			//IL_09a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ad: Expected O, but got Unknown
			//IL_09b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bf: Expected O, but got Unknown
			//IL_09d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09db: Expected O, but got Unknown
			//IL_09fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a01: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a07: Expected O, but got Unknown
			//IL_0a22: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a27: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2d: Expected O, but got Unknown
			//IL_0a48: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a53: Expected O, but got Unknown
			//IL_0a6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a73: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a79: Expected O, but got Unknown
			//IL_0a94: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a99: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9f: Expected O, but got Unknown
			//IL_0aba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac5: Expected O, but got Unknown
			//IL_0ae0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aeb: Expected O, but got Unknown
			//IL_0b2f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b36: Expected O, but got Unknown
			//IL_0b53: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b06: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b11: Expected O, but got Unknown
			PluginConfigurator val = PluginConfigurator.Create("Maurice Baller", "bitmotte.MauriceBaller");
			ConfigSpace val2 = new ConfigSpace(val.rootPanel, 15f);
			clean = new ButtonField(val.rootPanel, "Clean up", "clean");
			ConfigSpace val3 = new ConfigSpace(val.rootPanel, 15f);
			ConfigPanel val4 = new ConfigPanel(val.rootPanel, "Breakers", "breakers");
			ConfigSpace val5 = new ConfigSpace(val4, 15f);
			resetBreakers = new ButtonField(val4, "Reset", "reset_breakers");
			enableAllBreakers = new ButtonField(val4, "Enable All", "enable_all_breakers");
			disableAllBreakers = new ButtonField(val4, "Disable All", "disable_all_breakers");
			ConfigSpace val6 = new ConfigSpace(val4, 15f);
			groundSlamBreaker = new BoolField(val4, "Ground Slam", "ground slam", true);
			heavypunchBreaker = new BoolField(val4, "Knuckleblaster", "heavypunch", false);
			punchBreaker = new BoolField(val4, "Feedbacker", "punch", false);
			ConfigSpace val7 = new ConfigSpace(val4, 15f);
			explosionBreaker = new BoolField(val4, "Explosion", "explosion", false);
			zapBreaker = new BoolField(val4, "Zap by conduction spread", "zap", true);
			projectileBreaker = new BoolField(val4, "Miscellaneous projectiles", "projectile", false);
			environmentBreaker = new BoolField(val4, "Environment", "environment", true);
			acidBreaker = new BoolField(val4, "Acid", "acid", true);
			fireBreaker = new BoolField(val4, "Fire", "fire", false);
			ConfigSpace val8 = new ConfigSpace(val4, 15f);
			revolverBreaker = new BoolField(val4, "Revolver beam", "revolver", false);
			ConfigSpace val9 = new ConfigSpace(val4, 15f);
			shotgunBreaker = new BoolField(val4, "Shotgun pellet", "shotgun", false);
			shotgunzoneBreaker = new BoolField(val4, "Close proximity shotgun blast", "shotgunzone", false);
			chainsawzoneBreaker = new BoolField(val4, "Melee chainsaw tick", "chainsawzone", false);
			chainsawBreaker = new BoolField(val4, "Detached chainsaw", "chainsaw", false);
			chainsawprojectileBreaker = new BoolField(val4, "Flying chainsaw", "chainsawprojectile", false);
			hammerBreaker = new BoolField(val4, "Impact hammer hit", "hammer", false);
			ConfigSpace val10 = new ConfigSpace(val4, 15f);
			nailBreaker = new BoolField(val4, "Nail", "nail", false);
			harpoonBreaker = new BoolField(val4, "Magnet", "harpoon", true);
			zapperBreaker = new BoolField(val4, "Conduction cable finished", "zapper", false);
			aftershockBreaker = new BoolField(val4, "Zapped by self conduction", "aftershock", false);
			sawbladeBreaker = new BoolField(val4, "Sawblade", "sawblade", true);
			ConfigSpace val11 = new ConfigSpace(val4, 15f);
			railcannonBreaker = new BoolField(val4, "Railcannon Beam", "railcannon", false);
			drillBreaker = new BoolField(val4, "Screwdriver tick", "drill", false);
			drillpunchBreaker = new BoolField(val4, "drillpunch (not corkscrew blow))", "drillpunch", false);
			ConfigSpace val12 = new ConfigSpace(val4, 15f);
			cannonballBreaker = new BoolField(val4, "Cannonball", "cannonball", false);
			ConfigSpace val13 = new ConfigSpace(val4, 15f);
			shotgun0Breaker = new BoolField(val4, "Shotgun core hitscan", "shotgun0", false);
			rocket0Breaker = new BoolField(val4, "Rocket hitscan", "rocket0", false);
			ConfigSpace val14 = new ConfigSpace(val4, 15f);
			ConfigHeader val15 = new ConfigHeader(val4, "Notice : Initial shockwave counts as enemy . . . It will instantly break .", 13, (TextAlignmentOptions)513);
			enemyBreaker = new BoolField(val4, "Enemy", "enemy", false);
			ConfigSpace val16 = new ConfigSpace(val.rootPanel, 15f);
			ConfigHeader val17 = new ConfigHeader(val.rootPanel, "Ball", 24, (TextAlignmentOptions)513);
			ConfigHeader val18 = new ConfigHeader(val.rootPanel, "Notice : Some configs live update .", 14, (TextAlignmentOptions)513);
			gravity = new BoolField(val.rootPanel, "Gravity", "gravity", true);
			ConfigSpace val19 = new ConfigSpace(val.rootPanel, 7f);
			gravityScale = new FloatSliderField(val.rootPanel, "Mass", "mass", new Tuple<float, float>(0.1f, 100f), 1f);
			gravityScaleVariance = new FloatSliderField(val.rootPanel, "Variance", "mass_variance", new Tuple<float, float>(0f, 100f), 0.5f);
			ConfigSpace val20 = new ConfigSpace(val.rootPanel, 7f);
			bounciness = new FloatSliderField(val.rootPanel, "Bounciness", "bounciness", new Tuple<float, float>(0f, 1f), 0.5f);
			bouncinessVariance = new FloatSliderField(val.rootPanel, "Variance", "bounciness_variance", new Tuple<float, float>(0f, 1f), 0.3f);
			ConfigSpace val21 = new ConfigSpace(val.rootPanel, 7f);
			legs = new BoolField(val.rootPanel, "Spider Legs", "legs", true);
			ConfigSpace val22 = new ConfigSpace(val.rootPanel, 15f);
			ConfigHeader val23 = new ConfigHeader(val.rootPanel, "Secret Variations", 24, (TextAlignmentOptions)513);
			ConfigHeader val24 = new ConfigHeader(val.rootPanel, "Notice : There are 13 variations .", 14, (TextAlignmentOptions)513);
			variantJingle = new BoolField(val.rootPanel, "Jingle", "variant_jingle", true);
			variantChance = new FloatSliderField(val.rootPanel, "Chance ( % )", "variant_chance", new Tuple<float, float>(0f, 100f), 1f);
			ConfigPanel val25 = new ConfigPanel(val.rootPanel, "Individual Likelihood", "variant_likelihood");
			ConfigSpace val26 = new ConfigSpace(val25, 15f);
			resetVariants = new ButtonField(val25, "Reset", "reset_variants");
			maxOutAllVariants = new ButtonField(val25, "Max Out All", "max_out_all_variants");
			disableAllVariants = new ButtonField(val25, "Disable All", "disable_all_variants");
			ConfigSpace val27 = new ConfigSpace(val25, 15f);
			plushieChance = new FloatSliderField(val25, "Plushie", "plushie", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val28 = new ConfigHeader(val25, "Credit to Bitmotte ( mod developer ) for the idea", 14, (TextAlignmentOptions)513);
			goldChance = new FloatSliderField(val25, "Gold", "gold", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val29 = new ConfigHeader(val25, "Credit to @TProfilePicture on YouTube for the idea", 14, (TextAlignmentOptions)513);
			eyeChance = new FloatSliderField(val25, "Eye", "eye", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val30 = new ConfigHeader(val25, "Credit to u/iamayoutuberiswear on Reddit for the idea", 14, (TextAlignmentOptions)513);
			lossChance = new FloatSliderField(val25, "Loss", "loss", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val31 = new ConfigHeader(val25, "Credit to u/Fit-Recognition-7016 on Reddit for the idea", 14, (TextAlignmentOptions)513);
			evilMeanGreenChance = new FloatSliderField(val25, "Evil Mean Green", "evil_mean_green", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val32 = new ConfigHeader(val25, "Credit to u/finding_my_father on Reddit for the idea", 14, (TextAlignmentOptions)513);
			bigChance = new FloatSliderField(val25, "Massive Sky Faller", "big", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val33 = new ConfigHeader(val25, "Credit to u/Longjumping_Age8031 on Reddit for the idea", 14, (TextAlignmentOptions)513);
			virtueChance = new FloatSliderField(val25, "Virtue Orb", "virtue", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val34 = new ConfigHeader(val25, "Credit to u/Malicious_Maurice on Reddit for the idea", 14, (TextAlignmentOptions)513);
			maurfireChance = new FloatSliderField(val25, "Maurfire", "maurfire", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val35 = new ConfigHeader(val25, "Credit to u/SingerNo5708 on Reddit for the idea", 14, (TextAlignmentOptions)513);
			lookerChance = new FloatSliderField(val25, "Looker", "looker", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val36 = new ConfigHeader(val25, "Credit to u/C_Franssens on Reddit for the idea", 14, (TextAlignmentOptions)513);
			falseVirtueChance = new FloatSliderField(val25, "False Virtue", "false_virtue", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val37 = new ConfigHeader(val25, "Credit to u/NoProgress7287 on Reddit for the idea", 14, (TextAlignmentOptions)513);
			ballriceChance = new FloatSliderField(val25, "Ballrice", "ballrice", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val38 = new ConfigHeader(val25, "Credit to u/FUR_Varsik14_52 on Reddit for the idea", 14, (TextAlignmentOptions)513);
			moaiChance = new FloatSliderField(val25, "Moai", "moai", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val39 = new ConfigHeader(val25, "Credit to u/DontKnowLunar on Reddit for the idea", 14, (TextAlignmentOptions)513);
			ballerBlockManChance = new FloatSliderField(val25, "Baller", "baller_block_man", new Tuple<float, float>(0f, 5f), 1f);
			ConfigHeader val40 = new ConfigHeader(val25, "Credit to u/Traditional_Boot9840 on Reddit for the idea", 14, (TextAlignmentOptions)513);
			ConfigSpace val41 = new ConfigSpace(val.rootPanel, 15f);
			ConfigHeader val42 = new ConfigHeader(val.rootPanel, "Notice : Cheats can be found in the cheats menu .", 20, (TextAlignmentOptions)513);
			ConfigSpace val43 = new ConfigSpace(val.rootPanel, 15f);
			ConfigHeader val44 = new ConfigHeader(val.rootPanel, "Join my discord for sneak peeks,devlogs,and the possibility to test my mods early ! !", 20, (TextAlignmentOptions)513);
			joinDC = new ButtonField(val.rootPanel, "Join my Discord", "joinDC");
			ConfigSpace val45 = new ConfigSpace(val.rootPanel, 15f);
			object obj = <>O.<0>__UpdateGlobalConfig;
			if (obj == null)
			{
				PostConfigChangeEvent val46 = UpdateGlobalConfig;
				<>O.<0>__UpdateGlobalConfig = val46;
				obj = (object)val46;
			}
			val.postConfigChange += (PostConfigChangeEvent)obj;
			UpdateGlobalConfig();
			ButtonField obj2 = joinDC;
			object obj3 = <>O.<1>__OpenDiscord;
			if (obj3 == null)
			{
				OnClick val47 = OpenDiscord;
				<>O.<1>__OpenDiscord = val47;
				obj3 = (object)val47;
			}
			obj2.onClick += (OnClick)obj3;
			ButtonField obj4 = clean;
			object obj5 = <>O.<2>__CleanCorpses;
			if (obj5 == null)
			{
				OnClick val48 = GlobalConfig.CleanCorpses;
				<>O.<2>__CleanCorpses = val48;
				obj5 = (object)val48;
			}
			obj4.onClick += (OnClick)obj5;
			ButtonField obj6 = maxOutAllVariants;
			object obj7 = <>O.<3>__EnableAllVariants;
			if (obj7 == null)
			{
				OnClick val49 = EnableAllVariants;
				<>O.<3>__EnableAllVariants = val49;
				obj7 = (object)val49;
			}
			obj6.onClick += (OnClick)obj7;
			ButtonField obj8 = disableAllVariants;
			object obj9 = <>O.<4>__DisableAllVariants;
			if (obj9 == null)
			{
				OnClick val50 = DisableAllVariants;
				<>O.<4>__DisableAllVariants = val50;
				obj9 = (object)val50;
			}
			obj8.onClick += (OnClick)obj9;
			ButtonField obj10 = resetVariants;
			object obj11 = <>O.<5>__ResetAllVariants;
			if (obj11 == null)
			{
				OnClick val51 = ResetAllVariants;
				<>O.<5>__ResetAllVariants = val51;
				obj11 = (object)val51;
			}
			obj10.onClick += (OnClick)obj11;
			ButtonField obj12 = resetBreakers;
			object obj13 = <>O.<6>__ResetAllBreakers;
			if (obj13 == null)
			{
				OnClick val52 = ResetAllBreakers;
				<>O.<6>__ResetAllBreakers = val52;
				obj13 = (object)val52;
			}
			obj12.onClick += (OnClick)obj13;
			ButtonField obj14 = enableAllBreakers;
			object obj15 = <>O.<7>__EnableAllBreakers;
			if (obj15 == null)
			{
				OnClick val53 = EnableAllBreakers;
				<>O.<7>__EnableAllBreakers = val53;
				obj15 = (object)val53;
			}
			obj14.onClick += (OnClick)obj15;
			ButtonField obj16 = disableAllBreakers;
			object obj17 = <>O.<8>__DisableAllBreakers;
			if (obj17 == null)
			{
				OnClick val54 = DisableAllBreakers;
				<>O.<8>__DisableAllBreakers = val54;
				obj17 = (object)val54;
			}
			obj16.onClick += (OnClick)obj17;
			AssetBundle val55 = BundleTool.Load("balls.bundle");
			Texture2D val56 = (Texture2D)val55.LoadAsset("Assets/baller.png");
			val.icon = Sprite.Create(val56, new Rect(0f, 0f, (float)((Texture)val56).width, (float)((Texture)val56).height), new Vector2(0.5f, 0.5f), 100f);
			val55.Unload(false);
			return val;
		}

		private static void UpdateGlobalConfig()
		{
			GlobalConfig.breakers["ground slam"] = groundSlamBreaker.value;
			GlobalConfig.breakers["heavypunch"] = heavypunchBreaker.value;
			GlobalConfig.breakers["punch"] = punchBreaker.value;
			GlobalConfig.breakers["explosion"] = explosionBreaker.value;
			GlobalConfig.breakers["zap"] = zapBreaker.value;
			GlobalConfig.breakers["projectile"] = projectileBreaker.value;
			GlobalConfig.breakers["environment"] = environmentBreaker.value;
			GlobalConfig.breakers["acid"] = acidBreaker.value;
			GlobalConfig.breakers["fire"] = fireBreaker.value;
			GlobalConfig.breakers["revolver"] = revolverBreaker.value;
			GlobalConfig.breakers["shotgun"] = shotgunBreaker.value;
			GlobalConfig.breakers["shotgunzone"] = shotgunzoneBreaker.value;
			GlobalConfig.breakers["chainsawzone"] = chainsawzoneBreaker.value;
			GlobalConfig.breakers["chainsaw"] = chainsawBreaker.value;
			GlobalConfig.breakers["chainsawprojectile"] = chainsawprojectileBreaker.value;
			GlobalConfig.breakers["hammer"] = hammerBreaker.value;
			GlobalConfig.breakers["nail"] = nailBreaker.value;
			GlobalConfig.breakers["harpoon"] = harpoonBreaker.value;
			GlobalConfig.breakers["zapper"] = zapperBreaker.value;
			GlobalConfig.breakers["aftershock"] = aftershockBreaker.value;
			GlobalConfig.breakers["sawblade"] = sawbladeBreaker.value;
			GlobalConfig.breakers["railcannon"] = railcannonBreaker.value;
			GlobalConfig.breakers["drill"] = drillBreaker.value;
			GlobalConfig.breakers["drillpunch"] = drillpunchBreaker.value;
			GlobalConfig.breakers["cannonball"] = cannonballBreaker.value;
			GlobalConfig.breakers["shotgun0"] = shotgun0Breaker.value;
			GlobalConfig.breakers["rocket0"] = rocket0Breaker.value;
			GlobalConfig.breakers["enemy"] = enemyBreaker.value;
			GlobalConfig.gravity = gravity.value;
			GlobalConfig.gravityScale = gravityScale.value;
			GlobalConfig.gravityScaleVariance = gravityScaleVariance.value;
			GlobalConfig.bounciness = bounciness.value;
			GlobalConfig.bouncinessVariance = bouncinessVariance.value;
			GlobalConfig.legs = legs.value;
			GlobalConfig.variantJingle = variantJingle.value;
			GlobalConfig.variantChance = variantChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)plushieChance).guid] = plushieChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)goldChance).guid] = goldChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)eyeChance).guid] = eyeChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)lossChance).guid] = lossChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)evilMeanGreenChance).guid] = evilMeanGreenChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)bigChance).guid] = bigChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)virtueChance).guid] = virtueChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)maurfireChance).guid] = maurfireChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)lookerChance).guid] = lookerChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)falseVirtueChance).guid] = falseVirtueChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)ballriceChance).guid] = ballriceChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)moaiChance).guid] = moaiChance.value;
			GlobalConfig.individualVariantChances[((ConfigField)ballerBlockManChance).guid] = ballerBlockManChance.value;
			GlobalConfig.totalVariantChances = 0f;
			GlobalConfig.totalVariantChances += plushieChance.value;
			GlobalConfig.totalVariantChances += goldChance.value;
			GlobalConfig.totalVariantChances += eyeChance.value;
			GlobalConfig.totalVariantChances += lossChance.value;
			GlobalConfig.totalVariantChances += evilMeanGreenChance.value;
			GlobalConfig.totalVariantChances += bigChance.value;
			GlobalConfig.totalVariantChances += virtueChance.value;
			GlobalConfig.totalVariantChances += maurfireChance.value;
			GlobalConfig.totalVariantChances += lookerChance.value;
			GlobalConfig.totalVariantChances += falseVirtueChance.value;
			GlobalConfig.totalVariantChances += ballriceChance.value;
			GlobalConfig.totalVariantChances += moaiChance.value;
			GlobalConfig.totalVariantChances += ballerBlockManChance.value;
		}

		private static void EnableAllBreakers()
		{
			groundSlamBreaker.value = true;
			groundSlamBreaker.TriggerValueChangeEvent();
			heavypunchBreaker.value = true;
			heavypunchBreaker.TriggerValueChangeEvent();
			punchBreaker.value = true;
			punchBreaker.TriggerValueChangeEvent();
			explosionBreaker.value = true;
			explosionBreaker.TriggerValueChangeEvent();
			zapBreaker.value = true;
			zapBreaker.TriggerValueChangeEvent();
			projectileBreaker.value = true;
			projectileBreaker.TriggerValueChangeEvent();
			environmentBreaker.value = true;
			environmentBreaker.TriggerValueChangeEvent();
			acidBreaker.value = true;
			acidBreaker.TriggerValueChangeEvent();
			fireBreaker.value = true;
			fireBreaker.TriggerValueChangeEvent();
			revolverBreaker.value = true;
			revolverBreaker.TriggerValueChangeEvent();
			shotgunBreaker.value = true;
			shotgunBreaker.TriggerValueChangeEvent();
			shotgunzoneBreaker.value = true;
			shotgunzoneBreaker.TriggerValueChangeEvent();
			chainsawzoneBreaker.value = true;
			chainsawzoneBreaker.TriggerValueChangeEvent();
			chainsawBreaker.value = true;
			chainsawBreaker.TriggerValueChangeEvent();
			chainsawprojectileBreaker.value = true;
			chainsawprojectileBreaker.TriggerValueChangeEvent();
			hammerBreaker.value = true;
			hammerBreaker.TriggerValueChangeEvent();
			nailBreaker.value = true;
			nailBreaker.TriggerValueChangeEvent();
			harpoonBreaker.value = true;
			harpoonBreaker.TriggerValueChangeEvent();
			zapperBreaker.value = true;
			zapperBreaker.TriggerValueChangeEvent();
			aftershockBreaker.value = true;
			aftershockBreaker.TriggerValueChangeEvent();
			sawbladeBreaker.value = true;
			sawbladeBreaker.TriggerValueChangeEvent();
			railcannonBreaker.value = true;
			railcannonBreaker.TriggerValueChangeEvent();
			drillBreaker.value = true;
			drillBreaker.TriggerValueChangeEvent();
			drillpunchBreaker.value = true;
			drillpunchBreaker.TriggerValueChangeEvent();
			cannonballBreaker.value = true;
			cannonballBreaker.TriggerValueChangeEvent();
			shotgun0Breaker.value = true;
			shotgun0Breaker.TriggerValueChangeEvent();
			rocket0Breaker.value = true;
			rocket0Breaker.TriggerValueChangeEvent();
			enemyBreaker.value = true;
			enemyBreaker.TriggerValueChangeEvent();
		}

		private static void DisableAllBreakers()
		{
			groundSlamBreaker.value = false;
			groundSlamBreaker.TriggerValueChangeEvent();
			heavypunchBreaker.value = false;
			heavypunchBreaker.TriggerValueChangeEvent();
			punchBreaker.value = false;
			punchBreaker.TriggerValueChangeEvent();
			explosionBreaker.value = false;
			explosionBreaker.TriggerValueChangeEvent();
			zapBreaker.value = false;
			zapBreaker.TriggerValueChangeEvent();
			projectileBreaker.value = false;
			projectileBreaker.TriggerValueChangeEvent();
			environmentBreaker.value = false;
			environmentBreaker.TriggerValueChangeEvent();
			acidBreaker.value = false;
			acidBreaker.TriggerValueChangeEvent();
			fireBreaker.value = false;
			fireBreaker.TriggerValueChangeEvent();
			revolverBreaker.value = false;
			revolverBreaker.TriggerValueChangeEvent();
			shotgunBreaker.value = false;
			shotgunBreaker.TriggerValueChangeEvent();
			shotgunzoneBreaker.value = false;
			shotgunzoneBreaker.TriggerValueChangeEvent();
			chainsawzoneBreaker.value = false;
			chainsawzoneBreaker.TriggerValueChangeEvent();
			chainsawBreaker.value = false;
			chainsawBreaker.TriggerValueChangeEvent();
			chainsawprojectileBreaker.value = false;
			chainsawprojectileBreaker.TriggerValueChangeEvent();
			hammerBreaker.value = false;
			hammerBreaker.TriggerValueChangeEvent();
			nailBreaker.value = false;
			nailBreaker.TriggerValueChangeEvent();
			harpoonBreaker.value = false;
			harpoonBreaker.TriggerValueChangeEvent();
			zapperBreaker.value = false;
			zapperBreaker.TriggerValueChangeEvent();
			aftershockBreaker.value = false;
			aftershockBreaker.TriggerValueChangeEvent();
			sawbladeBreaker.value = false;
			sawbladeBreaker.TriggerValueChangeEvent();
			railcannonBreaker.value = false;
			railcannonBreaker.TriggerValueChangeEvent();
			drillBreaker.value = false;
			drillBreaker.TriggerValueChangeEvent();
			drillpunchBreaker.value = false;
			drillpunchBreaker.TriggerValueChangeEvent();
			cannonballBreaker.value = false;
			cannonballBreaker.TriggerValueChangeEvent();
			shotgun0Breaker.value = false;
			shotgun0Breaker.TriggerValueChangeEvent();
			rocket0Breaker.value = false;
			rocket0Breaker.TriggerValueChangeEvent();
			enemyBreaker.value = false;
			enemyBreaker.TriggerValueChangeEvent();
		}

		private static void ResetAllBreakers()
		{
			groundSlamBreaker.value = groundSlamBreaker.defaultValue;
			groundSlamBreaker.TriggerValueChangeEvent();
			heavypunchBreaker.value = heavypunchBreaker.defaultValue;
			heavypunchBreaker.TriggerValueChangeEvent();
			punchBreaker.value = punchBreaker.defaultValue;
			punchBreaker.TriggerValueChangeEvent();
			explosionBreaker.value = explosionBreaker.defaultValue;
			explosionBreaker.TriggerValueChangeEvent();
			zapBreaker.value = zapBreaker.defaultValue;
			zapBreaker.TriggerValueChangeEvent();
			projectileBreaker.value = projectileBreaker.defaultValue;
			projectileBreaker.TriggerValueChangeEvent();
			environmentBreaker.value = environmentBreaker.defaultValue;
			environmentBreaker.TriggerValueChangeEvent();
			acidBreaker.value = acidBreaker.defaultValue;
			acidBreaker.TriggerValueChangeEvent();
			fireBreaker.value = fireBreaker.defaultValue;
			fireBreaker.TriggerValueChangeEvent();
			revolverBreaker.value = revolverBreaker.defaultValue;
			revolverBreaker.TriggerValueChangeEvent();
			shotgunBreaker.value = shotgunBreaker.defaultValue;
			shotgunBreaker.TriggerValueChangeEvent();
			shotgunzoneBreaker.value = shotgunzoneBreaker.defaultValue;
			shotgunzoneBreaker.TriggerValueChangeEvent();
			chainsawzoneBreaker.value = chainsawzoneBreaker.defaultValue;
			chainsawzoneBreaker.TriggerValueChangeEvent();
			chainsawBreaker.value = chainsawBreaker.defaultValue;
			chainsawBreaker.TriggerValueChangeEvent();
			chainsawprojectileBreaker.value = chainsawBreaker.defaultValue;
			chainsawprojectileBreaker.TriggerValueChangeEvent();
			hammerBreaker.value = hammerBreaker.defaultValue;
			hammerBreaker.TriggerValueChangeEvent();
			nailBreaker.value = nailBreaker.defaultValue;
			nailBreaker.TriggerValueChangeEvent();
			harpoonBreaker.value = harpoonBreaker.defaultValue;
			harpoonBreaker.TriggerValueChangeEvent();
			zapperBreaker.value = zapperBreaker.defaultValue;
			zapperBreaker.TriggerValueChangeEvent();
			aftershockBreaker.value = aftershockBreaker.defaultValue;
			aftershockBreaker.TriggerValueChangeEvent();
			sawbladeBreaker.value = sawbladeBreaker.defaultValue;
			sawbladeBreaker.TriggerValueChangeEvent();
			railcannonBreaker.value = railcannonBreaker.defaultValue;
			railcannonBreaker.TriggerValueChangeEvent();
			drillBreaker.value = drillBreaker.defaultValue;
			drillBreaker.TriggerValueChangeEvent();
			drillpunchBreaker.value = drillpunchBreaker.defaultValue;
			drillpunchBreaker.TriggerValueChangeEvent();
			cannonballBreaker.value = cannonballBreaker.defaultValue;
			cannonballBreaker.TriggerValueChangeEvent();
			shotgun0Breaker.value = shotgun0Breaker.defaultValue;
			shotgun0Breaker.TriggerValueChangeEvent();
			rocket0Breaker.value = rocket0Breaker.defaultValue;
			rocket0Breaker.TriggerValueChangeEvent();
			enemyBreaker.value = enemyBreaker.defaultValue;
			enemyBreaker.TriggerValueChangeEvent();
		}

		private static void EnableAllVariants()
		{
			plushieChance.value = 5f;
			plushieChance.TriggerValueChangeEvent();
			goldChance.value = 5f;
			goldChance.TriggerValueChangeEvent();
			eyeChance.value = 5f;
			eyeChance.TriggerValueChangeEvent();
			lossChance.value = 5f;
			lossChance.TriggerValueChangeEvent();
			evilMeanGreenChance.value = 5f;
			evilMeanGreenChance.TriggerValueChangeEvent();
			bigChance.value = 5f;
			bigChance.TriggerValueChangeEvent();
			virtueChance.value = 5f;
			virtueChance.TriggerValueChangeEvent();
			maurfireChance.value = 5f;
			maurfireChance.TriggerValueChangeEvent();
			lookerChance.value = 5f;
			lookerChance.TriggerValueChangeEvent();
			falseVirtueChance.value = 5f;
			falseVirtueChance.TriggerValueChangeEvent();
			ballriceChance.value = 5f;
			ballriceChance.TriggerValueChangeEvent();
			moaiChance.value = 5f;
			moaiChance.TriggerValueChangeEvent();
			ballerBlockManChance.value = 5f;
			ballerBlockManChance.TriggerValueChangeEvent();
		}

		private static void DisableAllVariants()
		{
			plushieChance.value = 0f;
			plushieChance.TriggerValueChangeEvent();
			goldChance.value = 0f;
			goldChance.TriggerValueChangeEvent();
			eyeChance.value = 0f;
			eyeChance.TriggerValueChangeEvent();
			lossChance.value = 0f;
			lossChance.TriggerValueChangeEvent();
			evilMeanGreenChance.value = 0f;
			evilMeanGreenChance.TriggerValueChangeEvent();
			bigChance.value = 0f;
			bigChance.TriggerValueChangeEvent();
			virtueChance.value = 0f;
			virtueChance.TriggerValueChangeEvent();
			maurfireChance.value = 0f;
			maurfireChance.TriggerValueChangeEvent();
			lookerChance.value = 0f;
			lookerChance.TriggerValueChangeEvent();
			falseVirtueChance.value = 0f;
			falseVirtueChance.TriggerValueChangeEvent();
			ballriceChance.value = 0f;
			ballriceChance.TriggerValueChangeEvent();
			moaiChance.value = 0f;
			moaiChance.TriggerValueChangeEvent();
			ballerBlockManChance.value = 0f;
			ballerBlockManChance.TriggerValueChangeEvent();
		}

		private static void ResetAllVariants()
		{
			plushieChance.value = plushieChance.defaultValue;
			plushieChance.TriggerValueChangeEvent();
			goldChance.value = goldChance.defaultValue;
			goldChance.TriggerValueChangeEvent();
			eyeChance.value = eyeChance.defaultValue;
			eyeChance.TriggerValueChangeEvent();
			lossChance.value = lossChance.defaultValue;
			lossChance.TriggerValueChangeEvent();
			evilMeanGreenChance.value = evilMeanGreenChance.defaultValue;
			evilMeanGreenChance.TriggerValueChangeEvent();
			bigChance.value = bigChance.defaultValue;
			bigChance.TriggerValueChangeEvent();
			virtueChance.value = virtueChance.defaultValue;
			virtueChance.TriggerValueChangeEvent();
			maurfireChance.value = maurfireChance.defaultValue;
			maurfireChance.TriggerValueChangeEvent();
			lookerChance.value = lookerChance.defaultValue;
			lookerChance.TriggerValueChangeEvent();
			falseVirtueChance.value = falseVirtueChance.defaultValue;
			falseVirtueChance.TriggerValueChangeEvent();
			ballriceChance.value = ballriceChance.defaultValue;
			ballriceChance.TriggerValueChangeEvent();
			moaiChance.value = moaiChance.defaultValue;
			moaiChance.TriggerValueChangeEvent();
			ballerBlockManChance.value = ballerBlockManChance.defaultValue;
			ballerBlockManChance.TriggerValueChangeEvent();
		}

		private static void OpenDiscord()
		{
			Process.Start("http://discord.gg/pVdr9e6hZ8");
		}
	}
	[HarmonyPatch(typeof(MaliciousFace), "HandleCollision")]
	[HarmonyPriority(500)]
	public class BallPatch : MonoBehaviour
	{
		private static bool Prefix(MaliciousFace __instance, Collision other)
		{
			//IL_007d: 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)
			//IL_00a5: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			Breakable val = default(Breakable);
			if (other.gameObject.TryGetComponent<Breakable>(ref val) && !val.playerOnly && !val.specialCaseOnly)
			{
				val.Break();
				return false;
			}
			if (!LayerMaskDefaults.IsMatchingLayer(other.gameObject.layer, (LMD)1))
			{
				return false;
			}
			if (other.gameObject.CompareTag("Floor"))
			{
				Object.Instantiate<GameObject>(__instance.impactParticle, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
				((Quaternion)(ref __instance.spriteRot)).eulerAngles = new Vector3(((ContactPoint)(ref other.contacts[0])).normal.x + 90f, ((ContactPoint)(ref other.contacts[0])).normal.y, ((ContactPoint)(ref other.contacts[0])).normal.z);
				__instance.spritePos = new Vector3(((ContactPoint)(ref other.contacts[0])).point.x, ((ContactPoint)(ref other.contacts[0])).point.y + 0.1f, ((ContactPoint)(ref other.contacts[0])).point.z);
				Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.shockwave), __instance.spritePos, Quaternion.identity);
				MonoSingleton<CameraController>.Instance.CameraShake(2f);
			}
			SecretVariations.MakeBallWithSecretPossibility(((Component)__instance).gameObject);
			__instance.BreakCorpse();
			return false;
		}
	}
	[HarmonyPatch(typeof(TargetTracker), "RegisterTarget")]
	public class DontTargetBallPatch : MonoBehaviour
	{
		private static bool Prefix(TargetTracker __instance, ITarget target, CancellationToken token)
		{
			if ((Object)(object)target.EID == (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)target.EID).GetComponent<MaliciousCorpse>() != (Object)null)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EnemyInfoPage), "Start")]
	public class Bestiary : MonoBehaviour
	{
		private static void Prefix(EnemyInfoPage __instance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			if (GlobalConfig.bestiaryAlreadyAdded)
			{
				return;
			}
			AssetBundle val = BundleTool.Load("balls.bundle");
			SpawnableObject val2 = (SpawnableObject)ScriptableObject.CreateInstance("SpawnableObject");
			if (Store.legger)
			{
				val2 = (SpawnableObject)val.LoadAsset("Assets/Baller/Bestiary/MaliciousCorpse Legger.asset");
			}
			if (Store.armer)
			{
				val2 = (SpawnableObject)val.LoadAsset("Assets/Baller/Bestiary/MaliciousCorpse Armer.asset");
			}
			if (Store.legger && Store.armer)
			{
				val2 = (SpawnableObject)val.LoadAsset("Assets/Baller/Bestiary/MaliciousCorpse LegArm.asset");
			}
			if (!Store.legger && !Store.armer)
			{
				val2 = (SpawnableObject)val.LoadAsset("Assets/Baller/Bestiary/MaliciousCorpse.asset");
			}
			SetupResource.FixShader(val2.preview);
			SetupResource.FixShader(val2.gameObject);
			SpawnableObject[] array = Array.Empty<SpawnableObject>();
			SpawnableObject[] enemies = __instance.objects.enemies;
			foreach (SpawnableObject val3 in enemies)
			{
				SpawnableObject[] array2 = array;
				int num = 0;
				SpawnableObject[] array3 = (SpawnableObject[])(object)new SpawnableObject[1 + array2.Length];
				ReadOnlySpan<SpawnableObject> readOnlySpan = new ReadOnlySpan<SpawnableObject>(array2);
				readOnlySpan.CopyTo(new Span<SpawnableObject>(array3).Slice(num, readOnlySpan.Length));
				num += readOnlySpan.Length;
				array3[num] = val3;
				array = array3;
				if (val3.objectName == "Malicious Face")
				{
					array3 = array;
					num = 0;
					array2 = (SpawnableObject[])(object)new SpawnableObject[1 + array3.Length];
					readOnlySpan = new ReadOnlySpan<SpawnableObject>(array3);
					readOnlySpan.CopyTo(new Span<SpawnableObject>(array2).Slice(num, readOnlySpan.Length));
					num += readOnlySpan.Length;
					array2[num] = val2;
					array = array2;
				}
			}
			__instance.objects.enemies = array;
			GlobalConfig.bestiaryAlreadyAdded = true;
			val.Unload(false);
		}
	}
	[HarmonyPatch(typeof(SpawnMenu), "Awake")]
	public class SandboxItem : MonoBehaviour
	{
		private static void Prefix(SpawnMenu __instance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			if (!GlobalConfig.sandboxItemAlreadyAdded)
			{
				AssetBundle val = BundleTool.Load("balls.bundle");
				SpawnableObject val2 = (SpawnableObject)ScriptableObject.CreateInstance("SpawnableObject");
				if (Store.legger)
				{
					val2 = (SpawnableObject)val.LoadAsset("Assets/Baller/Bestiary/MaliciousCorpse Legger.asset");
				}
				if (Store.armer)
				{
					val2 = (SpawnableObject)val.LoadAsset("Assets/Baller/Bestiary/MaliciousCorpse Armer.asset");
				}
				if (Store.legger && Store.armer)
				{
					val2 = (SpawnableObject)val.LoadAsset("Assets/Baller/Bestiary/MaliciousCorpse LegArm.asset");
				}
				if (!Store.legger && !Store.armer)
				{
					val2 = (SpawnableObject)val.LoadAsset("Assets/Baller/Bestiary/MaliciousCorpse.asset");
				}
				SetupResource.FixShader(val2.preview);
				SetupResource.FixShader(val2.gameObject);
				((Component)val2.gameObject.transform.GetChild(1).GetChild(0).GetChild(1)
					.GetChild(0)).gameObject.AddComponent<CorpseLegController>();
				val2.gameObject.AddComponent<MaliciousCorpse>();
				if ((Object)(object)Store.storedPhysicalLeg != (Object)null)
				{
					GameObject val3 = Object.Instantiate<GameObject>(Store.storedPhysicalLeg);
					val3.transform.parent = val2.gameObject.transform.GetChild(0);
				}
				if ((Object)(object)Store.storedPhysicalArm != (Object)null)
				{
					GameObject val4 = Object.Instantiate<GameObject>(Store.storedPhysicalArm);
					val4.transform.parent = val2.gameObject.transform.GetChild(0);
				}
				val2.spawnableObjectType = (SpawnableObjectDataType)4;
				val2.gameObject.AddComponent<DontKinematic>();
				val2.backgroundColor = new Color(0.8f, 0.8f, 0.8f);
				SpawnableObjectsDatabase objects = __instance.objects;
				SpawnableObject[] objects2 = __instance.objects.objects;
				int num = 0;
				SpawnableObject[] array = (SpawnableObject[])(object)new SpawnableObject[1 + objects2.Length];
				ReadOnlySpan<SpawnableObject> readOnlySpan = new ReadOnlySpan<SpawnableObject>(objects2);
				readOnlySpan.CopyTo(new Span<SpawnableObject>(array).Slice(num, readOnlySpan.Length));
				num += readOnlySpan.Length;
				array[num] = val2;
				objects.objects = array;
				GlobalConfig.sandboxItemAlreadyAdded = true;
				val.Unload(false);
			}
		}
	}
	public class DontKinematic : MonoBehaviour
	{
		private void Awake()
		{
			Rigidbody[] componentsInChildren = ((Component)this).GetComponentsInChildren<Rigidbody>();
			foreach (Rigidbody val in componentsInChildren)
			{
				val.isKinematic = false;
			}
		}
	}
	public class EvilMeanGreen : MonoBehaviour
	{
		public GameObject green;

		private GameObject greenFlash;

		private void OnCollisionEnter(Collision other)
		{
			if (((Component)other.transform).CompareTag("Player"))
			{
				GameObject val = GameObject.Find("Canvas");
				greenFlash = Object.Instantiate<GameObject>(green);
				greenFlash.transform.parent = val.transform;
				((MonoBehaviour)this).Invoke("Destroy", 2.99f);
			}
		}

		private void Destroy()
		{
			Object.Destroy((Object)(object)greenFlash);
		}
	}
	public class CorpseLegController : MonoBehaviour
	{
		public BallerLeg[] legs;

		public LineRenderer exampleRenderer;

		public Material legMat;

		private void Awake()
		{
			//IL_0037: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			exampleRenderer = ((Component)((Component)this).transform).GetComponent<LineRenderer>();
			for (int i = 0; i < 4; i++)
			{
				BallerLeg ballerLeg = ((Component)((Component)this).transform.GetChild(i)).gameObject.AddComponent<BallerLeg>();
				legMat = Addressables.LoadAssetAsync<Material>((object)"Assets/Materials/Dev/SpiderLeg.mat").WaitForCompletion();
				((Renderer)ballerLeg.legRenderer).material = legMat;
				ballerLeg.legRenderer.widthCurve = exampleRenderer.widthCurve;
				ballerLeg.legRenderer.colorGradient = exampleRenderer.colorGradient;
				ballerLeg.legRenderer.alignment = exampleRenderer.alignment;
				ballerLeg.legRenderer.numCapVertices = exampleRenderer.numCapVertices;
				((Renderer)ballerLeg.legRenderer).lightProbeUsage = ((Renderer)exampleRenderer).lightProbeUsage;
				((Renderer)ballerLeg.legRenderer).allowOcclusionWhenDynamic = ((Renderer)exampleRenderer).allowOcclusionWhenDynamic;
				legs = legs.Append(ballerLeg).ToArray();
			}
		}
	}
	public class MaliciousCorpse : EnemyScript
	{
		public EnemyIdentifier eid;

		public Enemy en;

		public Machine mach;

		public Rigidbody rb;

		public Collider mainCollider;

		public CustomGravity gravityScaler;

		public Animator controller;

		private bool dead = false;

		public bool variation = false;

		private float gravityVariant;

		private float bouncinessVariant;

		private Vector3 prevVelocity;

		public void Start()
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			GameObject[] allCorpses = SceneUtility.allCorpses;
			int num = 0;
			GameObject[] array = (GameObject[])(object)new GameObject[1 + allCorpses.Length];
			ReadOnlySpan<GameObject> readOnlySpan = new ReadOnlySpan<GameObject>(allCorpses);
			readOnlySpan.CopyTo(new Span<GameObject>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			array[num] = ((Component)this).gameObject;
			SceneUtility.allCorpses = array;
			eid = ((Component)this).GetComponent<EnemyIdentifier>();
			en = ((Component)this).GetComponent<Enemy>();
			mach = ((Component)this).GetComponent<Machine>();
			rb = ((Component)this).GetComponent<Rigidbody>();
			mainCollider = ((Component)this).GetComponent<Collider>();
			gravityScaler = ((Component)this).GetComponent<CustomGravity>();
			controller = ((Component)this).GetComponent<Animator>();
			UnityEvent val = new UnityEvent();
			val.AddListener(new UnityAction(Break));
			eid.onDeath = val;
			if (variation && GlobalConfig.variantJingle)
			{
				controller.SetBoolString("Variation", true);
			}
			gravityVariant = Random.Range((0f - GlobalConfig.gravityScaleVariance) / 1.5f, GlobalConfig.gravityScaleVariance / 1.5f);
			bouncinessVariant = Random.Range((0f - GlobalConfig.bouncinessVariance) / 1.5f, GlobalConfig.bouncinessVariance / 1.5f);
			CheckConfig();
			Transform child = ((Component)this).transform.GetChild(1).GetChild(0).GetChild(1)
				.GetChild(0);
			if ((Object)(object)child != (Object)null && (!GlobalConfig.legs || Store.leggerSpiderLegsAreDisabled))
			{
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
		}

		public override void OnDamage(ref DamageData data)
		{
			bool flag = false;
			foreach (KeyValuePair<string, bool> breaker in GlobalConfig.breakers)
			{
				if (breaker.Key != data.hitter || !breaker.Value)
				{
					continue;
				}
				flag = true;
				break;
			}
			if (eid.health <= 0f || flag)
			{
				Break();
			}
		}

		private void OnCollisionEnter(Collision other)
		{
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			controller.SetTriggerString("Hit");
			if (!MonoSingleton<CheatsManager>.Instance.GetCheatState("mauriceballer.rollkill"))
			{
				return;
			}
			EnemyIdentifier val = other.gameObject.GetComponent<EnemyIdentifier>();
			if ((Object)(object)val == (Object)null)
			{
				EnemyIdentifierIdentifier component = other.gameObject.GetComponent<EnemyIdentifierIdentifier>();
				if ((Object)(object)component != (Object)null && (Object)(object)component.eid != (Object)null)
				{
					val = component.eid;
				}
			}
			IdolMauricer val2 = default(IdolMauricer);
			if ((Object)(object)val == (Object)null && other.gameObject.TryGetComponent<IdolMauricer>(ref val2))
			{
				val = other.gameObject.GetComponentInParent<EnemyIdentifier>();
			}
			if ((Object)(object)val == (Object)null || Object.op_Implicit((Object)(object)((Component)val).gameObject.GetComponent<MaliciousCorpse>()) || !Object.op_Implicit((Object)(object)val) || !((Object)(object)val != (Object)(object)eid))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)MonoSingleton<StyleHUD>.Instance) && !val.dead)
			{
				switch (Random.Range(1, 4))
				{
				case 1:
					MonoSingleton<StyleHUD>.Instance.AddPoints(50, "mauriceballer.rollkill1", (GameObject)null, eid, -1, "", "");
					break;
				case 2:
					MonoSingleton<StyleHUD>.Instance.AddPoints(50, "mauriceballer.rollkill2", (GameObject)null, eid, -1, "", "");
					break;
				case 3:
					MonoSingleton<StyleHUD>.Instance.AddPoints(50, "mauriceballer.rollkill3", (GameObject)null, eid, -1, "", "");
					break;
				default:
					MonoSingleton<StyleHUD>.Instance.AddPoints(50, "mauriceballer.rollkill3", (GameObject)null, eid, -1, "", "");
					break;
				}
			}
			val.hitter = "maurice";
			val.SimpleDamage(999f);
			rb.velocity = prevVelocity;
		}

		private void LateUpdate()
		{
			//IL_001b: 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)
			if (!((Object)(object)rb == (Object)null))
			{
				prevVelocity = rb.velocity;
			}
		}

		public void Break()
		{
			rb.constraints = (RigidbodyConstraints)126;
			Object.Destroy((Object)(object)gravityScaler);
			eid.health = 0f;
			en.health = 0f;
			((Enemy)mach).health = 0f;
			eid.ForceGetHealth();
			((Component)((Component)this).gameObject.transform.GetChild(1).GetChild(0).GetChild(1)).gameObject.SetActive(false);
			Collider[] componentsInChildren = ((Component)this).GetComponentsInChildren<Collider>();
			foreach (Collider val in componentsInChildren)
			{
				val.enabled = false;
			}
			((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(false);
			((MonoBehaviour)this).Invoke("Destroy", 3f);
			dead = true;
		}

		public void CheckConfig()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			((MonoBehaviour)this).Invoke("CheckConfig", 1f);
			if (!dead)
			{
				rb.useGravity = GlobalConfig.gravity;
				gravityScaler.useGravity = GlobalConfig.gravity;
				gravityScaler.gravity = new Vector3(gravityScaler.gravity.x, 0f - GlobalConfig.gravityScale + gravityVariant, gravityScaler.gravity.z);
				if (gravityScaler.gravity.y < -100f)
				{
					gravityScaler.gravity = new Vector3(gravityScaler.gravity.x, -100f, gravityScaler.gravity.z);
				}
				if (gravityScaler.gravity.y > -0.1f)
				{
					gravityScaler.gravity = new Vector3(gravityScaler.gravity.x, -0.1f, gravityScaler.gravity.z);
				}
				mainCollider.material.bounciness = GlobalConfig.bounciness + bouncinessVariant;
				if (mainCollider.material.bounciness > 1f)
				{
					mainCollider.material.bounciness = 1f;
				}
				if (mainCollider.material.bounciness < 0f)
				{
					mainCollider.material.bounciness = 0f;
				}
			}
		}

		public void Destroy()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	public static class SecretVariations
	{
		public static void MakeBallWithSecretPossibility(GameObject gameObject)
		{
			float num = Random.Range(0f, 100f);
			if (num <= GlobalConfig.variantChance)
			{
				float num2 = Random.Range(0f, GlobalConfig.totalVariantChances);
				float num3 = 0f;
				foreach (KeyValuePair<string, float> individualVariantChance in GlobalConfig.individualVariantChances)
				{
					num3 += individualVariantChance.Value;
					if (num3 == 0f || num3 <= num2)
					{
						continue;
					}
					switch (individualVariantChance.Key)
					{
					case "plushie":
						Simple("Assets/Baller/Variations/Plush/DevPlushie (bitmotte).prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Plushie Variant Loaded");
						break;
					case "gold":
						GenericCorpse("Assets/Baller/Variations/Gold/Gold.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Gold Variant Loaded");
						break;
					case "eye":
						CorpseNoLegs("Assets/Baller/Variations/HellEye/HellEye.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Eye Variant Loaded");
						break;
					case "loss":
						GenericCorpse("Assets/Baller/Variations/Loss/Loss.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Loss Variant Loaded");
						break;
					case "evil_mean_green":
						EvilMeanGreen("Assets/Baller/Variations/EvilMeanGreen/Green.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Evil Mean Green Variant Loaded");
						break;
					case "big":
						GenericCorpse("Assets/Baller/Variations/Big/Big.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Big Variant Loaded");
						break;
					case "virtue":
						CorpseNoLegs("Assets/Baller/Variations/Virtue/Virtue.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Virtue Variant Loaded");
						break;
					case "maurfire":
						GenericCorpse("Assets/Baller/Variations/Maurfire/Maurfire.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Maurfire Variant Loaded");
						break;
					case "looker":
						GenericCorpse("Assets/Baller/Variations/Looker/Looker.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Looker Variant Loaded");
						break;
					case "false_virtue":
						GenericCorpse("Assets/Baller/Variations/FalseVirtue/FalseVirtue.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"False Virtue Variant Loaded");
						break;
					case "ballrice":
						GenericCorpse("Assets/Baller/Variations/Ballrice/Ballrice.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Ballrice Variant Loaded");
						break;
					case "moai":
						CorpseNoLegs("Assets/Baller/Variations/Moai/Moai.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Moai Variant Loaded");
						break;
					case "baller_block_man":
						CorpseNoLegs("Assets/Baller/Variations/BallerBlockMan/BallerBlockMan.prefab", gameObject);
						Plugin.Logger.LogInfo((object)"Baller Variant Loaded");
						break;
					default:
						Plugin.Logger.LogInfo((object)"Failed to pick variation");
						break;
					}
					break;
				}
				if (num3 != 0f)
				{
					return;
				}
			}
			GenericCorpseNoJingle("Assets/Baller/Corpse/MaliciousCorpse.prefab", gameObject);
		}

		public static void GenericCorpseNoJingle(string key, GameObject dead)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_005c: 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)
			AssetBundle val = BundleTool.Load("balls.bundle");
			GameObject val2 = (GameObject)val.LoadAsset(key);
			SetupResource.FixShader(val2);
			val2.AddComponent<MaliciousCorpse>();
			((Component)val2.transform.GetChild(1).GetChild(0).GetChild(1)
				.GetChild(0)).gameObject.AddComponent<CorpseLegController>();
			val2.transform.position = dead.transform.position;
			val2.transform.rotation = dead.transform.rotation;
			GameObject val3 = Object.Instantiate<GameObject>(val2);
			Store.corpse = ((Component)val3.transform.GetChild(0)).gameObject;
			val.Unload(false);
		}

		public static void GenericCorpse(string key, GameObject dead)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0063: 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)
			AssetBundle val = BundleTool.Load("balls.bundle");
			GameObject val2 = (GameObject)val.LoadAsset(key);
			SetupResource.FixShader(val2);
			MaliciousCorpse maliciousCorpse = val2.AddComponent<MaliciousCorpse>();
			maliciousCorpse.variation = true;
			((Component)val2.transform.GetChild(1).GetChild(0).GetChild(1)
				.GetChild(0)).gameObject.AddComponent<CorpseLegController>();
			val2.transform.position = dead.transform.position;
			val2.transform.rotation = dead.transform.rotation;
			GameObject val3 = Object.Instantiate<GameObject>(val2);
			val.Unload(false);
		}

		public static void CorpseNoLegs(string key, GameObject dead)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0063: 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)
			AssetBundle val = BundleTool.Load("balls.bundle");
			GameObject val2 = (GameObject)val.LoadAsset(key);
			SetupResource.FixShader(val2);
			MaliciousCorpse maliciousCorpse = val2.AddComponent<MaliciousCorpse>();
			maliciousCorpse.variation = true;
			Object.Destroy((Object)(object)((Component)val2.transform.GetChild(1).GetChild(0).GetChild(1)
				.GetChild(0)).gameObject);
			val2.transform.position = dead.transform.position;
			val2.transform.rotation = dead.transform.rotation;
			Object.Instantiate<GameObject>(val2);
			val.Unload(false);
		}

		public static void Simple(string key, GameObject dead)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			AssetBundle val = BundleTool.Load("balls.bundle");
			GameObject val2 = (GameObject)val.LoadAsset(key);
			SetupResource.FixShader(val2);
			val2.transform.position = dead.transform.position;
			val2.transform.rotation = dead.transform.rotation;
			GameObject val3 = Object.Instantiate<GameObject>(val2);
			GameObject[] allCorpses = SceneUtility.allCorpses;
			int num = 0;
			GameObject[] array = (GameObject[])(object)new GameObject[1 + allCorpses.Length];
			ReadOnlySpan<GameObject> readOnlySpan = new ReadOnlySpan<GameObject>(allCorpses);
			readOnlySpan.CopyTo(new Span<GameObject>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			array[num] = val3;
			SceneUtility.allCorpses = array;
			if (GlobalConfig.variantJingle)
			{
				val3.GetComponent<Animator>().SetBoolString("Variant", true);
			}
			val.Unload(false);
		}

		public static void EvilMeanGreen(string key, GameObject dead)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0080: 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)
			AssetBundle val = BundleTool.Load("balls.bundle");
			GameObject val2 = (GameObject)val.LoadAsset(key);
			SetupResource.FixShader(val2);
			MaliciousCorpse maliciousCorpse = val2.AddComponent<MaliciousCorpse>();
			maliciousCorpse.variation = true;
			EvilMeanGreen evilMeanGreen = val2.AddComponent<EvilMeanGreen>();
			evilMeanGreen.green = (GameObject)val.LoadAsset("Assets/Baller/Variations/EvilMeanGreen/GreenFlash.prefab");
			((Component)val2.transform.GetChild(1).GetChild(0).GetChild(1)
				.GetChild(0)).gameObject.AddComponent<CorpseLegController>();
			val2.transform.position = dead.transform.position;
			val2.transform.rotation = dead.transform.rotation;
			Object.Instantiate<GameObject>(val2);
			val.Unload(false);
		}
	}
	[BepInPlugin("bitmotte.MauriceBaller", "Maurice Baller", "2.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		public static PluginConfigurator config;

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin bitmotte.MauriceBaller is loaded!");
			Harmony val = new Harmony("bitmotte.MauriceBaller");
			val.PatchAll();
			GlobalConfig.InitGlobalConfig();
			config = MauriceConfigurator.CreateConfigurator();
			RegisterCheats.Register();
			SceneManager.sceneLoaded += SceneUtility.OnSceneLoad;
			Store.baller = true;
		}
	}
	public static class BundleTool
	{
		public static AssetBundle Load(string fileName)
		{
			return AssetBundle.LoadFromMemory(EmbeddedAccess.AccessFile(fileName));
		}
	}
	public static class EmbeddedAccess
	{
		public static byte[] AccessFile(string fileName)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			byte[] array;
			using (Stream stream = executingAssembly.GetManifestResourceStream("MauriceBaller.resources." + fileName))
			{
				if (stream == null)
				{
					return null;
				}
				array = new byte[stream.Length];
				stream.Read(array, 0, array.Length);
			}
			return array;
		}
	}
	public static class SceneUtility
	{
		public static string sceneName;

		public static GameObject[] allCorpses = Array.Empty<GameObject>();

		public static void OnSceneLoad(Scene scene, LoadSceneMode mode)
		{
			allCorpses = Array.Empty<GameObject>();
			sceneName = ((Scene)(ref scene)).name;
		}
	}
	public static class SetupResource
	{
		public static GameObject FixShader(GameObject gameObject)
		{
			//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_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)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			Shader shader = Addressables.LoadAssetAsync<Material>((object)"Assets/Materials/Environment/Metal/Pattern 1/Metal Pattern 1 8.mat").WaitForCompletion().shader;
			SkinnedMeshRenderer[] componentsInChildren = gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				Material[] materials = ((Renderer)val).materials;
				foreach (Material val2 in materials)
				{
					if (((Object)val2.shader).name == "Hidden/InternalErrorShader")
					{
						val2.shader = Addressables.LoadAssetAsync<Material>((object)"Assets/Materials/Dev/FadeToWhite.mat").WaitForCompletion().shader;
					}
					else
					{
						val2.shader = shader;
					}
				}
			}
			MeshRenderer[] componentsInChildren2 = gameObject.GetComponentsInChildren<MeshRenderer>();
			foreach (MeshRenderer val3 in componentsInChildren2)
			{
				Material[] materials2 = ((Renderer)val3).materials;
				foreach (Material val4 in materials2)
				{
					if (((Object)val4.shader).name == "Hidden/InternalErrorShader")
					{
						val4.shader = Addressables.LoadAssetAsync<Material>((object)"Assets/Materials/Dev/FadeToWhite.mat").WaitForCompletion().shader;
					}
					else
					{
						val4.shader = shader;
					}
				}
			}
			ParticleSystem[] componentsInChildren3 = gameObject.GetComponentsInChildren<ParticleSystem>();
			foreach (ParticleSystem val5 in componentsInChildren3)
			{
				Renderer[] componentsInChildren4 = ((Component)val5).gameObject.GetComponentsInChildren<Renderer>();
				foreach (Renderer val6 in componentsInChildren4)
				{
					Material[] materials3 = val6.materials;
					foreach (Material val7 in materials3)
					{
						if (((Object)val7.shader).name == "Hidden/InternalErrorShader")
						{
							val7.shader = Addressables.LoadAssetAsync<Material>((object)"Assets/Materials/Dev/FadeToWhite.mat").WaitForCompletion().shader;
						}
						else
						{
							val7.shader = shader;
						}
					}
				}
			}
			return gameObject;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "bitmotte.MauriceBaller";

		public const string PLUGIN_NAME = "Maurice Baller";

		public const string PLUGIN_VERSION = "2.0.0";
	}
}
namespace MauriceBaller.Cheats
{
	internal class RegisterCheats
	{
		public static void Register()
		{
			Plugin.Logger.LogInfo((object)"Registering Rollkill Cheat");
			SceneManager.sceneLoaded += OnSceneLoad;
		}

		private static void OnSceneLoad(Scene arg0, LoadSceneMode arg1)
		{
			CheatsManager instance = MonoSingleton<CheatsManager>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.RegisterCheat((ICheat)(object)new RollkillCheat(), "maurice baller");
			}
			MonoSingleton<StyleHUD>.Instance.RegisterStyleItem("mauriceballer.rollkill1", "THE ROLLING STONES");
			MonoSingleton<StyleHUD>.Instance.RegisterStyleItem("mauriceballer.rollkill2", "BOLICHE");
			MonoSingleton<StyleHUD>.Instance.RegisterStyleItem("mauriceballer.rollkill3", "BOWLRICED");
		}
	}
	internal class RollkillCheat : ICheat
	{
		public string LongName => "Corpses can crush enemies by rolling";

		public string Identifier => "mauriceballer.rollkill";

		public string ButtonEnabledOverride => "ON";

		public string ButtonDisabledOverride => "OFF";

		public string Icon => "ghost";

		public bool DefaultState => false;

		public StatePersistenceMode PersistenceMode => (StatePersistenceMode)1;

		public bool IsActive { get; private set; }

		public void Disable()
		{
			IsActive = false;
			Plugin.Logger.LogInfo((object)"Rollkill Cheat Disabled");
		}

		public void Enable(CheatsManager manager)
		{
			IsActive = true;
			Plugin.Logger.LogInfo((object)"Rollkill Cheat Enabled");
		}
	}
}