using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.FalseSon;
using HG.Reflection;
using IL.EntityStates.FalseSon;
using IL.RoR2;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.EntityStates;
using On.EntityStates.FalseSon;
using R2API;
using R2API.Utils;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("FalseSonFix")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("FalseSonFix")]
[assembly: AssemblyTitle("FalseSonFix")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FalseSonFix
{
	public static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	[BepInDependency("com.bepis.r2api", "5.3.0")]
	[BepInDependency("com.bepis.r2api.proctype", "1.0.2")]
	[BepInDependency("com.rune580.riskofoptions", "2.8.5")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.tetrapink.FalseSonFixes", "FalseSonFixes", "1.1.1")]
	public class Main : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_OnEnter <>9__21_0;

			public static Func<Instruction, bool> <>9__21_5;

			public static Func<Instruction, bool> <>9__21_6;

			public static Action<BulletAttack> <>9__21_4;

			public static Manipulator <>9__21_2;

			public static Func<Instruction, bool> <>9__21_8;

			public static Func<Instruction, bool> <>9__21_9;

			public static Func<LaserFatherCharged, float> <>9__21_7;

			public static Manipulator <>9__21_3;

			public static hook_OnEnter <>9__22_0;

			public static hook_OnEnter <>9__23_0;

			public static Func<Instruction, bool> <>9__23_3;

			public static Func<Instruction, bool> <>9__23_4;

			public static Func<Instruction, bool> <>9__23_5;

			public static Action<StepBrothers> <>9__23_2;

			public static Manipulator <>9__23_1;

			public static Func<Instruction, bool> <>9__24_3;

			public static Func<Instruction, bool> <>9__24_4;

			public static Func<Instruction, bool> <>9__24_5;

			public static Func<Instruction, bool> <>9__24_6;

			public static Func<HealthComponent, DamageInfo, float> <>9__24_2;

			public static Manipulator <>9__24_0;

			public static Func<Instruction, bool> <>9__24_8;

			public static Func<Instruction, bool> <>9__24_9;

			public static Func<Instruction, bool> <>9__24_10;

			public static Func<CharacterBody, int> <>9__24_7;

			public static Manipulator <>9__24_1;

			public static hook_HandleEarlyCancel <>9__25_0;

			public static hook_AuthorityFixedUpdate <>9__25_1;

			internal void <LaserFatherShit>b__21_0(orig_OnEnter orig, LaserFatherCharged self)
			{
				LaserFatherCharged.procCoefficientPerTick = lotfProcCoeff.Value;
				LaserFatherCharged.damageCoefficient = lotfPercentDamagePerTick.Value / 100f;
				LaserFatherCharged.baseFireFrequency = lotfBaseTicksPerSecond.Value;
				orig.Invoke(self);
				self.spikeRefillAmountPerSecond = 0f;
			}

			internal void <LaserFatherShit>b__21_2(ILContext ctx)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(ctx);
				if (val.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchNewobj<BulletAttack>(x),
					(Instruction x) => ILPatternMatchingExt.MatchDup(x)
				}))
				{
					val.Index += 2;
					val.EmitDelegate<Action<BulletAttack>>((Action<BulletAttack>)delegate(BulletAttack ba)
					{
						//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)
						ba.falloffModel = lotfFalloffModel.Value;
					});
					val.Emit(OpCodes.Dup);
				}
				else
				{
					Log.Error("lotf falloff");
				}
			}

			internal bool <LaserFatherShit>b__21_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchNewobj<BulletAttack>(x);
			}

			internal bool <LaserFatherShit>b__21_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchDup(x);
			}

			internal void <LaserFatherShit>b__21_4(BulletAttack ba)
			{
				//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)
				ba.falloffModel = lotfFalloffModel.Value;
			}

			internal void <LaserFatherShit>b__21_3(ILContext ctx)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(ctx);
				if (val.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.3f)
				}))
				{
					val.Index += 4;
					val.Emit(OpCodes.Pop);
					val.Emit(OpCodes.Ldarg_0);
					val.EmitDelegate<Func<LaserFatherCharged, float>>((Func<LaserFatherCharged, float>)((LaserFatherCharged laser) => LaserFatherCharged.baseFireFrequency * ((EntityState)laser).characterBody.attackSpeed));
				}
				else
				{
					Log.Error("lotf fire frequency thingy");
				}
			}

			internal bool <LaserFatherShit>b__21_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloc(x, 0);
			}

			internal bool <LaserFatherShit>b__21_9(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0.3f);
			}

			internal float <LaserFatherShit>b__21_7(LaserFatherCharged laser)
			{
				return LaserFatherCharged.baseFireFrequency * ((EntityState)laser).characterBody.attackSpeed;
			}

			internal void <BurtPatch>b__22_0(orig_OnEnter orig, LaserFatherBurstPrep self)
			{
				self.secondaryRefillPercentage = 0f;
				orig.Invoke(self);
				if (((EntityState)self).isAuthority)
				{
					GenericSkill skill = ((EntityState)self).skillLocator.GetSkill((SkillSlot)1);
					float num = burstRestockPercent.Value / 100f * (float)skill.maxStock;
					float rechargeStopwatch = skill.rechargeStopwatch;
					num += rechargeStopwatch / skill.finalRechargeInterval;
					skill.stock = (int)Mathf.Clamp((float)skill.stock + Mathf.Floor(num), (float)skill.stock, (float)skill.maxStock);
					skill.rechargeStopwatch = (num - Mathf.Floor(num)) * skill.finalRechargeInterval;
				}
			}

			internal void <StepBrothersPatch>b__23_0(orig_OnEnter orig, StepBrothers self)
			{
				orig.Invoke(self);
				self.overlapAttack.procCoefficient = 0f;
				StepBrothers.procCoefficient = stepExplosionProc.Value;
			}

			internal void <StepBrothersPatch>b__23_1(ILContext ctx)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(ctx);
				if (val.TryGotoNext(new Func<Instruction, bool>[3]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<StepBrothers>(x, "explosionAttack"),
					(Instruction x) => ILPatternMatchingExt.MatchLdsfld<StepBrothers>(x, "blastRadius")
				}))
				{
					val.Emit(OpCodes.Ldarg_0);
					val.EmitDelegate<Action<StepBrothers>>((Action<StepBrothers>)delegate(StepBrothers step)
					{
						step.explosionAttack.procCoefficient = StepBrothers.procCoefficient;
					});
				}
				else
				{
					Log.Error("sotb patch failed");
				}
			}

			internal bool <StepBrothersPatch>b__23_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdarg(x, 0);
			}

			internal bool <StepBrothersPatch>b__23_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<StepBrothers>(x, "explosionAttack");
			}

			internal bool <StepBrothersPatch>b__23_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld<StepBrothers>(x, "blastRadius");
			}

			internal void <StepBrothersPatch>b__23_2(StepBrothers step)
			{
				step.explosionAttack.procCoefficient = StepBrothers.procCoefficient;
			}

			internal void <LunarRuin>b__24_0(ILContext ctx)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: 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)
				ILCursor val = new ILCursor(ctx);
				if (val.TryGotoNext(new Func<Instruction, bool>[4]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<HealthComponent>(x, "body"),
					(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "lunarruin"),
					(Instruction x) => ILPatternMatchingExt.MatchCallvirt<CharacterBody>(x, "GetBuffCount")
				}))
				{
					val.Index += 7;
					val.Emit(OpCodes.Pop);
					val.Emit(OpCodes.Ldarg_0);
					val.Emit(OpCodes.Ldarg_1);
					val.EmitDelegate<Func<HealthComponent, DamageInfo, float>>((Func<HealthComponent, DamageInfo, float>)delegate(HealthComponent hc, DamageInfo info)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						//IL_0007: Unknown result type (might be due to invalid IL or missing references)
						//IL_001f: Unknown result type (might be due to invalid IL or missing references)
						if (!ProcTypeAPI.HasModdedProc(info.procChainMask, ruinProcType))
						{
							ProcTypeAPI.AddModdedProc(ref info.procChainMask, ruinProcType);
							return ruinDamagePercent.Value / 100f * (float)hc.body.GetBuffCount(Buffs.lunarruin);
						}
						return 0f;
					});
				}
				else
				{
					Log.Error("lunarruin patch failed");
				}
			}

			internal bool <LunarRuin>b__24_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdarg(x, 0);
			}

			internal bool <LunarRuin>b__24_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<HealthComponent>(x, "body");
			}

			internal bool <LunarRuin>b__24_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "lunarruin");
			}

			internal bool <LunarRuin>b__24_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallvirt<CharacterBody>(x, "GetBuffCount");
			}

			internal float <LunarRuin>b__24_2(HealthComponent hc, DamageInfo info)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				if (!ProcTypeAPI.HasModdedProc(info.procChainMask, ruinProcType))
				{
					ProcTypeAPI.AddModdedProc(ref info.procChainMask, ruinProcType);
					return ruinDamagePercent.Value / 100f * (float)hc.body.GetBuffCount(Buffs.lunarruin);
				}
				return 0f;
			}

			internal void <LunarRuin>b__24_1(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				int num = default(int);
				ILLabel val2 = default(ILLabel);
				if (val.TryGotoNext(new Func<Instruction, bool>[3]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 1),
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, ref num),
					(Instruction x) => ILPatternMatchingExt.MatchBlt(x, ref val2)
				}))
				{
					val.Emit(OpCodes.Ldarg_1);
					val.EmitDelegate<Func<CharacterBody, int>>((Func<CharacterBody, int>)((CharacterBody body) => body.HasBuff(Buffs.lunarruin) ? (-1) : 0));
					val.Emit(OpCodes.Ldloc_1);
					val.Emit(OpCodes.Add);
					val.Emit(OpCodes.Stloc_1);
				}
				else
				{
					Log.Error("deathmark patch failed");
				}
			}

			internal bool <LunarRuin>b__24_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloc(x, 1);
			}

			internal bool <LunarRuin>b__24_9(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchLdcI4(x, ref num);
			}

			internal bool <LunarRuin>b__24_10(Instruction x)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBlt(x, ref val);
			}

			internal int <LunarRuin>b__24_7(CharacterBody body)
			{
				return body.HasBuff(Buffs.lunarruin) ? (-1) : 0;
			}

			internal void <Slam>b__25_0(orig_HandleEarlyCancel orig, ClubSwing3 self)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				orig.Invoke(self);
				if (((EntityState)self).isAuthority && !((EntityState)self).characterMotor.isGrounded)
				{
					((EntityState)self).outer.SetNextState((EntityState)new OverheadClubSwing());
				}
			}

			internal void <Slam>b__25_1(orig_AuthorityFixedUpdate orig, BasicMeleeAttack self)
			{
				orig.Invoke(self);
				if (((EntityState)self).isAuthority && self is OverheadClubSwing && (double)((EntityState)self).fixedAge >= 0.067)
				{
					self.overlapAttack = null;
				}
			}
		}

		public const string ModGUID = "com.tetrapink.FalseSonFixes";

		public const string ModName = "FalseSonFixes";

		public const string ModVersion = "1.1.1";

		private static ModdedProcType ruinProcType;

		private static ConfigEntry<bool> applyRuinPatches;

		private static ConfigEntry<float> ruinDamagePercent;

		private static ConfigEntry<bool> applyStepPatches;

		private static ConfigEntry<float> stepExplosionProc;

		private static ConfigEntry<bool> applyLotfPatches;

		private static ConfigEntry<float> lotfProcCoeff;

		private static ConfigEntry<float> lotfPercentDamagePerTick;

		private static ConfigEntry<float> lotfBaseTicksPerSecond;

		private static ConfigEntry<float> lotfSecondaryRefreshRate;

		private static ConfigEntry<bool> lotfRestockScalesWithStock;

		private static ConfigEntry<bool> lotfRestockScalesWithCooldownReduction;

		private static ConfigEntry<FalloffModel> lotfFalloffModel;

		private static ConfigEntry<bool> applyBurtPatches;

		private static ConfigEntry<float> burstRestockPercent;

		private static ConfigEntry<bool> applySlamPatches;

		private static readonly string pictureData = "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";

		public void Awake()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Log.Init(((BaseUnityPlugin)this).Logger);
			ruinProcType = ProcTypeAPI.ReserveProcType();
			Configs();
			if (applyLotfPatches.Value)
			{
				LaserFatherShit();
			}
			if (applyBurtPatches.Value)
			{
				BurtPatch();
			}
			if (applyStepPatches.Value)
			{
				StepBrothersPatch();
			}
			if (applyRuinPatches.Value)
			{
				LunarRuin();
			}
			if (applySlamPatches.Value)
			{
				Slam();
			}
		}

		public void Configs()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Expected O, but got Unknown
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Expected O, but got Unknown
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: 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_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Expected O, but got Unknown
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Expected O, but got Unknown
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Expected O, but got Unknown
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Expected O, but got Unknown
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Expected O, but got Unknown
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Expected O, but got Unknown
			SetRiskOfOptionsImage();
			ModSettingsManager.SetModDescription("Fixes many bugs with False Son");
			applySlamPatches = ((BaseUnityPlugin)this).Config.Bind<bool>("Club of the Forsaken", "Enable fixes", true, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(applySlamPatches, true));
			applyRuinPatches = ((BaseUnityPlugin)this).Config.Bind<bool>("Lunar Ruin", "Enable fixes", true, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(applyRuinPatches, true));
			ruinDamagePercent = ((BaseUnityPlugin)this).Config.Bind<float>("Lunar Ruin", "Damage per stack", 10f, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new SliderOption(ruinDamagePercent, new SliderConfig
			{
				min = 0f,
				max = 100f,
				FormatString = "{0:0.0}%"
			}));
			applyStepPatches = ((BaseUnityPlugin)this).Config.Bind<bool>("Step of the Brothers", "Enable fixes", true, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(applyStepPatches, true));
			stepExplosionProc = ((BaseUnityPlugin)this).Config.Bind<float>("Step of the Brothers", "Explosion proc coefficient", 0.5f, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new SliderOption(stepExplosionProc, new SliderConfig
			{
				min = 0f,
				max = 2f,
				FormatString = "{0:0.00}"
			}));
			applyLotfPatches = ((BaseUnityPlugin)this).Config.Bind<bool>("Laser of the Father", "Enable fixes", true, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(applyLotfPatches, true));
			lotfBaseTicksPerSecond = ((BaseUnityPlugin)this).Config.Bind<float>("Laser of the Father", "Base tickrate", 8f, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new SliderOption(lotfBaseTicksPerSecond, new SliderConfig
			{
				min = 1f,
				max = 32f,
				FormatString = "{0:0.0}"
			}));
			lotfPercentDamagePerTick = ((BaseUnityPlugin)this).Config.Bind<float>("Laser of the Father", "Damage per tick (%)", 175f, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new SliderOption(lotfPercentDamagePerTick, new SliderConfig
			{
				min = 0f,
				max = 800f,
				FormatString = "{0:0.0}%"
			}));
			lotfProcCoeff = ((BaseUnityPlugin)this).Config.Bind<float>("Laser of the Father", "Proc coefficient", 0.45f, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new SliderOption(lotfProcCoeff, new SliderConfig
			{
				min = 0f,
				max = 4f,
				FormatString = "{0:0.00}"
			}));
			lotfSecondaryRefreshRate = ((BaseUnityPlugin)this).Config.Bind<float>("Laser of the Father", "Secondary recharge rate", 1f, "Arbitrary scalar applied to the restock rate");
			ModSettingsManager.AddOption((BaseOption)new SliderOption(lotfSecondaryRefreshRate, new SliderConfig
			{
				min = 0f,
				max = 4f,
				FormatString = "{0:0.00}"
			}));
			lotfRestockScalesWithStock = ((BaseUnityPlugin)this).Config.Bind<bool>("Laser of the Father", "Secondary recharge scales with Growth", true, "(e.g. if enabled, having double the base Secondary stock from Growth will double the recharge rate)");
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(lotfRestockScalesWithStock, false));
			lotfRestockScalesWithCooldownReduction = ((BaseUnityPlugin)this).Config.Bind<bool>("Laser of the Father", "Secondary recharge scales with CD", false, "If enabled, Laser of the Father will NOT recharge stocks faster if your cooldowns are shorter. This means that Laser of the Father itself will restore the same amount of stock regardless of any cooldown reduction items for any given amount of Growth");
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(lotfRestockScalesWithCooldownReduction, false));
			lotfFalloffModel = ((BaseUnityPlugin)this).Config.Bind<FalloffModel>("Laser of the Father", "Falloff model", (FalloffModel)1, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new ChoiceOption((ConfigEntryBase)(object)lotfFalloffModel));
			applyBurtPatches = ((BaseUnityPlugin)this).Config.Bind<bool>("Laser Burst", "Enable fixes", true, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(applyBurtPatches, true));
			burstRestockPercent = ((BaseUnityPlugin)this).Config.Bind<float>("Laser Burst", "Secondary restock percent", 50f, (ConfigDescription)null);
			ModSettingsManager.AddOption((BaseOption)new SliderOption(burstRestockPercent, new SliderConfig
			{
				min = 0f,
				max = 100f,
				FormatString = "{0:0.0}%"
			}));
		}

		private void LaserFatherShit()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			object obj = <>c.<>9__21_0;
			if (obj == null)
			{
				hook_OnEnter val = delegate(orig_OnEnter orig, LaserFatherCharged self)
				{
					LaserFatherCharged.procCoefficientPerTick = lotfProcCoeff.Value;
					LaserFatherCharged.damageCoefficient = lotfPercentDamagePerTick.Value / 100f;
					LaserFatherCharged.baseFireFrequency = lotfBaseTicksPerSecond.Value;
					orig.Invoke(self);
					self.spikeRefillAmountPerSecond = 0f;
				};
				<>c.<>9__21_0 = val;
				obj = (object)val;
			}
			LaserFatherCharged.OnEnter += (hook_OnEnter)obj;
			LaserFatherCharged.FixedUpdate += (hook_FixedUpdate)delegate(orig_FixedUpdate orig, LaserFatherCharged self)
			{
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a5: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				if (((EntityState)self).isAuthority)
				{
					self.fireFrequency = LaserFatherCharged.baseFireFrequency * ((EntityState)self).characterBody.attackSpeed;
					GenericSkill secondary = ((EntityState)self).skillLocator.secondary;
					float num = Mathf.Sqrt(secondary.baseRechargeInterval / 4f) + 1f;
					float num2 = (lotfRestockScalesWithCooldownReduction.Value ? secondary.CalculateFinalRechargeInterval() : secondary.baseRechargeInterval) / secondary.baseRechargeInterval;
					float num3 = (lotfRestockScalesWithStock.Value ? ((float)secondary.maxStock / (float)(secondary.maxStock - ((EntityState)self).characterBody.extraSecondaryFromSkill)) : 1f);
					secondary.rechargeStopwatch += Time.fixedDeltaTime * num3 * num * 2f * lotfSecondaryRefreshRate.Value * num2;
					RaycastHit val6 = default(RaycastHit);
					Ray val7 = default(Ray);
					while (self.fireStopwatch > 1f / self.fireFrequency)
					{
						Vector3 val4 = ((Ray)(ref self.aimRay)).origin;
						if (Object.op_Implicit((Object)(object)self.muzzleTransform))
						{
							val4 = self.muzzleTransform.position;
						}
						Vector3 val5;
						if (Object.op_Implicit((Object)(object)self.lockedOnHurtBox))
						{
							val5 = ((Component)self.lockedOnHurtBox).transform.position;
						}
						else
						{
							TrajectoryAimAssist.ApplyTrajectoryAimAssist(ref self.aimRay, LaserFatherCharged.maxDistance, ((Component)this).gameObject, 1f);
							val5 = ((!Util.CharacterRaycast(((EntityState)self).gameObject, self.aimRay, ref val6, LaserFatherCharged.maxDistance, LayerMask.op_Implicit(LayerMask.op_Implicit(((LayerIndex)(ref LayerIndex.world)).mask) | LayerMask.op_Implicit(((LayerIndex)(ref LayerIndex.entityPrecise)).mask)), (QueryTriggerInteraction)1)) ? ((Ray)(ref self.aimRay)).GetPoint(LaserFatherCharged.maxDistance) : ((RaycastHit)(ref val6)).point);
						}
						((Ray)(ref val7))..ctor(val4, val5 - val4);
						string text = "MuzzleLaser";
						Transform modelTransform = self.modelTransform;
						Ray val8 = val7;
						Vector3 val9 = val5 - ((Ray)(ref val7)).origin;
						self.FireBullet(modelTransform, val8, text, ((Vector3)(ref val9)).magnitude + 0.1f);
						self.fireStopwatch -= 1f / self.fireFrequency;
					}
				}
			};
			object obj2 = <>c.<>9__21_2;
			if (obj2 == null)
			{
				Manipulator val2 = delegate(ILContext ctx)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_0093: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val4 = new ILCursor(ctx);
					if (val4.TryGotoNext(new Func<Instruction, bool>[2]
					{
						(Instruction x) => ILPatternMatchingExt.MatchNewobj<BulletAttack>(x),
						(Instruction x) => ILPatternMatchingExt.MatchDup(x)
					}))
					{
						val4.Index += 2;
						val4.EmitDelegate<Action<BulletAttack>>((Action<BulletAttack>)delegate(BulletAttack ba)
						{
							//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)
							ba.falloffModel = lotfFalloffModel.Value;
						});
						val4.Emit(OpCodes.Dup);
					}
					else
					{
						Log.Error("lotf falloff");
					}
				};
				<>c.<>9__21_2 = val2;
				obj2 = (object)val2;
			}
			LaserFatherCharged.FireBullet += (Manipulator)obj2;
			object obj3 = <>c.<>9__21_3;
			if (obj3 == null)
			{
				Manipulator val3 = delegate(ILContext ctx)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_006d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0079: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val4 = new ILCursor(ctx);
					if (val4.TryGotoNext(new Func<Instruction, bool>[2]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.3f)
					}))
					{
						val4.Index += 4;
						val4.Emit(OpCodes.Pop);
						val4.Emit(OpCodes.Ldarg_0);
						val4.EmitDelegate<Func<LaserFatherCharged, float>>((Func<LaserFatherCharged, float>)((LaserFatherCharged laser) => LaserFatherCharged.baseFireFrequency * ((EntityState)laser).characterBody.attackSpeed));
					}
					else
					{
						Log.Error("lotf fire frequency thingy");
					}
				};
				<>c.<>9__21_3 = val3;
				obj3 = (object)val3;
			}
			LaserFatherCharged.OnEnter += (Manipulator)obj3;
		}

		private void BurtPatch()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			object obj = <>c.<>9__22_0;
			if (obj == null)
			{
				hook_OnEnter val = delegate(orig_OnEnter orig, LaserFatherBurstPrep self)
				{
					self.secondaryRefillPercentage = 0f;
					orig.Invoke(self);
					if (((EntityState)self).isAuthority)
					{
						GenericSkill skill = ((EntityState)self).skillLocator.GetSkill((SkillSlot)1);
						float num = burstRestockPercent.Value / 100f * (float)skill.maxStock;
						float rechargeStopwatch = skill.rechargeStopwatch;
						num += rechargeStopwatch / skill.finalRechargeInterval;
						skill.stock = (int)Mathf.Clamp((float)skill.stock + Mathf.Floor(num), (float)skill.stock, (float)skill.maxStock);
						skill.rechargeStopwatch = (num - Mathf.Floor(num)) * skill.finalRechargeInterval;
					}
				};
				<>c.<>9__22_0 = val;
				obj = (object)val;
			}
			LaserFatherBurstPrep.OnEnter += (hook_OnEnter)obj;
		}

		private void StepBrothersPatch()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			object obj = <>c.<>9__23_0;
			if (obj == null)
			{
				hook_OnEnter val = delegate(orig_OnEnter orig, StepBrothers self)
				{
					orig.Invoke(self);
					self.overlapAttack.procCoefficient = 0f;
					StepBrothers.procCoefficient = stepExplosionProc.Value;
				};
				<>c.<>9__23_0 = val;
				obj = (object)val;
			}
			StepBrothers.OnEnter += (hook_OnEnter)obj;
			object obj2 = <>c.<>9__23_1;
			if (obj2 == null)
			{
				Manipulator val2 = delegate(ILContext ctx)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_0080: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val3 = new ILCursor(ctx);
					if (val3.TryGotoNext(new Func<Instruction, bool>[3]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdfld<StepBrothers>(x, "explosionAttack"),
						(Instruction x) => ILPatternMatchingExt.MatchLdsfld<StepBrothers>(x, "blastRadius")
					}))
					{
						val3.Emit(OpCodes.Ldarg_0);
						val3.EmitDelegate<Action<StepBrothers>>((Action<StepBrothers>)delegate(StepBrothers step)
						{
							step.explosionAttack.procCoefficient = StepBrothers.procCoefficient;
						});
					}
					else
					{
						Log.Error("sotb patch failed");
					}
				};
				<>c.<>9__23_1 = val2;
				obj2 = (object)val2;
			}
			StepBrothers.FixedUpdate += (Manipulator)obj2;
		}

		private void LunarRuin()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			object obj = <>c.<>9__24_0;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext ctx)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bd: 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)
					ILCursor val3 = new ILCursor(ctx);
					if (val3.TryGotoNext(new Func<Instruction, bool>[4]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdfld<HealthComponent>(x, "body"),
						(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "lunarruin"),
						(Instruction x) => ILPatternMatchingExt.MatchCallvirt<CharacterBody>(x, "GetBuffCount")
					}))
					{
						val3.Index += 7;
						val3.Emit(OpCodes.Pop);
						val3.Emit(OpCodes.Ldarg_0);
						val3.Emit(OpCodes.Ldarg_1);
						val3.EmitDelegate<Func<HealthComponent, DamageInfo, float>>((Func<HealthComponent, DamageInfo, float>)delegate(HealthComponent hc, DamageInfo info)
						{
							//IL_0002: Unknown result type (might be due to invalid IL or missing references)
							//IL_0007: Unknown result type (might be due to invalid IL or missing references)
							//IL_001f: Unknown result type (might be due to invalid IL or missing references)
							if (!ProcTypeAPI.HasModdedProc(info.procChainMask, ruinProcType))
							{
								ProcTypeAPI.AddModdedProc(ref info.procChainMask, ruinProcType);
								return ruinDamagePercent.Value / 100f * (float)hc.body.GetBuffCount(Buffs.lunarruin);
							}
							return 0f;
						});
					}
					else
					{
						Log.Error("lunarruin patch failed");
					}
				};
				<>c.<>9__24_0 = val;
				obj = (object)val;
			}
			HealthComponent.TakeDamageProcess += (Manipulator)obj;
			object obj2 = <>c.<>9__24_1;
			if (obj2 == null)
			{
				Manipulator val2 = delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_0080: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
					//IL_00be: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val3 = new ILCursor(il);
					int num = default(int);
					ILLabel val4 = default(ILLabel);
					if (val3.TryGotoNext(new Func<Instruction, bool>[3]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 1),
						(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, ref num),
						(Instruction x) => ILPatternMatchingExt.MatchBlt(x, ref val4)
					}))
					{
						val3.Emit(OpCodes.Ldarg_1);
						val3.EmitDelegate<Func<CharacterBody, int>>((Func<CharacterBody, int>)((CharacterBody body) => body.HasBuff(Buffs.lunarruin) ? (-1) : 0));
						val3.Emit(OpCodes.Ldloc_1);
						val3.Emit(OpCodes.Add);
						val3.Emit(OpCodes.Stloc_1);
					}
					else
					{
						Log.Error("deathmark patch failed");
					}
				};
				<>c.<>9__24_1 = val2;
				obj2 = (object)val2;
			}
			GlobalEventManager.ProcDeathMark += (Manipulator)obj2;
		}

		private void Slam()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			object obj = <>c.<>9__25_0;
			if (obj == null)
			{
				hook_HandleEarlyCancel val = delegate(orig_HandleEarlyCancel orig, ClubSwing3 self)
				{
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: Expected O, but got Unknown
					orig.Invoke(self);
					if (((EntityState)self).isAuthority && !((EntityState)self).characterMotor.isGrounded)
					{
						((EntityState)self).outer.SetNextState((EntityState)new OverheadClubSwing());
					}
				};
				<>c.<>9__25_0 = val;
				obj = (object)val;
			}
			ClubSwing3.HandleEarlyCancel += (hook_HandleEarlyCancel)obj;
			object obj2 = <>c.<>9__25_1;
			if (obj2 == null)
			{
				hook_AuthorityFixedUpdate val2 = delegate(orig_AuthorityFixedUpdate orig, BasicMeleeAttack self)
				{
					orig.Invoke(self);
					if (((EntityState)self).isAuthority && self is OverheadClubSwing && (double)((EntityState)self).fixedAge >= 0.067)
					{
						self.overlapAttack = null;
					}
				};
				<>c.<>9__25_1 = val2;
				obj2 = (object)val2;
			}
			BasicMeleeAttack.AuthorityFixedUpdate += (hook_AuthorityFixedUpdate)obj2;
		}

		private void SetRiskOfOptionsImage()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			byte[] array = Convert.FromBase64String(pictureData);
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array);
			Sprite modIcon = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			ModSettingsManager.SetModIcon(modIcon);
		}
	}
}