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 HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
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(".NETFramework,Version=v4.8", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("YuzusQoL")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Yuzu's QoL for Ultrakill")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("YuzusQoL")]
[assembly: AssemblyTitle("YuzusQoL")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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 YuzusQoL
{
	[BepInPlugin("yuzu.qol", "Yuzu's QoL", "1.0.0")]
	public class YuzusQoL : BaseUnityPlugin
	{
		public static ConfigEntry<float> StreetcleanerDamageMultiplier;

		public static ConfigEntry<float> MannequinHealthMultiplier;

		public static ConfigEntry<float> PiercerDamageMultiplier;

		public static ConfigEntry<float> PiercerChargeSpeedMultiplier;

		public static ConfigEntry<float> MaliciousRailcannonDamageMultiplier;

		public static ConfigEntry<float> MaliciousRailcannonExplosionRadiusMultiplier;

		public static ConfigEntry<int> MaliciousRailcannonSelfDamage;

		public static ConfigEntry<int> JackhammerBluntForceStyle;

		public static ConfigEntry<int> JackhammerHeavyHitterStyle;

		public static ConfigEntry<int> JackhammerFullImpactStyle;

		public static ConfigEntry<int> JackhammerHeavyHitStyle;

		public static ConfigEntry<float> JackhammerRegularHitStyleMultiplier;

		public static ConfigEntry<float> SisyphusParryVoiceVolume;

		public static ConfigEntry<float> MinosJudgementSpeedMultiplier;

		public static ConfigEntry<float> MinosCrushSpeedMultiplier;

		public static ConfigEntry<float> GeryonDashRegenMultiplier;

		public static YuzusQoL Instance { get; private set; }

		private void Awake()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Instance = this;
			InitConfig();
			Harmony val = new Harmony("yuzu.qol");
			val.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Yuzu's QoL loaded successfully!");
		}

		private void InitConfig()
		{
			StreetcleanerDamageMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "StreetcleanerDamageMultiplier", 0.55f, "Streetcleaner fire damage multiplier (0.55 = 45% reduction)");
			MannequinHealthMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Enemies", "MannequinHealthMultiplier", 0.7f, "Mannequin health multiplier (0.7 = 30% reduction)");
			PiercerDamageMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Weapons", "PiercerDamageMultiplier", 1.75f, "Piercer revolver damage multiplier (1.75 = 75% damage boost)");
			PiercerChargeSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Weapons", "PiercerChargeSpeedMultiplier", 1.5f, "Piercer revolver charge speed multiplier (1.5 = 50% faster charge)");
			MaliciousRailcannonDamageMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Weapons", "MaliciousRailcannonDamageMultiplier", 1.5f, "Malicious Railcannon damage multiplier (1.5 = 50% damage boost)");
			MaliciousRailcannonExplosionRadiusMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Weapons", "MaliciousRailcannonExplosionRadiusMultiplier", 1.25f, "Malicious Railcannon explosion radius multiplier (1.25 = 25% bigger radius)");
			MaliciousRailcannonSelfDamage = ((BaseUnityPlugin)this).Config.Bind<int>("Weapons", "MaliciousRailcannonSelfDamage", 15, "Damage the player takes from their own Malicious Railcannon explosion (vanilla: 50)");
			JackhammerBluntForceStyle = ((BaseUnityPlugin)this).Config.Bind<int>("Jackhammer", "BluntForcePoints", 120, "Style points for Blunt Force kill (vanilla: 80)");
			JackhammerHeavyHitterStyle = ((BaseUnityPlugin)this).Config.Bind<int>("Jackhammer", "HeavyHitterPoints", 180, "Style points for Heavy Hitter kill (vanilla: 120)");
			JackhammerFullImpactStyle = ((BaseUnityPlugin)this).Config.Bind<int>("Jackhammer", "FullImpactPoints", 360, "Style points for Full Impact kill (vanilla: 240)");
			JackhammerHeavyHitStyle = ((BaseUnityPlugin)this).Config.Bind<int>("Jackhammer", "HeavyHitPoints", 180, "Style points for heavy non-kill hit (vanilla: 120)");
			JackhammerRegularHitStyleMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Jackhammer", "RegularHitMultiplier", 1.5f, "Multiplier for regular hit style points (1.5 = 50% more)");
			SisyphusParryVoiceVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Bosses", "SisyphusParryVoiceVolume", 2f, "Volume of Sisyphus Prime's parry voiceline (default: 2.0 = double volume)");
			MinosJudgementSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Bosses", "MinosJudgementSpeedMultiplier", 0.75f, "Speed multiplier for Minos Prime's JUDGEMENT attack (0.75 = 25% slower)");
			MinosCrushSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Bosses", "MinosCrushSpeedMultiplier", 0.75f, "Speed multiplier for Minos Prime's CRUSH attack (0.75 = 25% slower)");
			GeryonDashRegenMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Bosses", "GeryonDashRegenMultiplier", 2f, "Dash regen speed multiplier during Geryon fight in 8-4 (2.0 = 2x faster)");
		}
	}
}
namespace YuzusQoL.Patches
{
	[HarmonyPatch(typeof(Enemy))]
	public class MannequinPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void ReduceHealth(Enemy __instance)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			try
			{
				if ((Object)(object)__instance == (Object)null)
				{
					Debug.LogWarning((object)"[Yuzu's QoL] Enemy instance is null!");
					return;
				}
				if (YuzusQoL.MannequinHealthMultiplier == null)
				{
					Debug.LogWarning((object)"[Yuzu's QoL] Config not initialized!");
					return;
				}
				EnemyIdentifier component = ((Component)__instance).GetComponent<EnemyIdentifier>();
				if ((Object)(object)component != (Object)null && (int)component.enemyType == 31)
				{
					float health = __instance.health;
					__instance.health *= YuzusQoL.MannequinHealthMultiplier.Value;
					component.health = __instance.health;
					Debug.Log((object)$"[Yuzu's QoL] Mannequin health: {health} -> {__instance.health}");
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in MannequinPatch: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(RevolverBeam))]
	public class PiercerBeamPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void BuffPiercerDamage(RevolverBeam __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (__instance.gunVariation == 0 && (int)__instance.beamType == 0 && __instance.hitAmount > 1 && !__instance.strongAlt && YuzusQoL.PiercerDamageMultiplier != null)
				{
					float damage = __instance.damage;
					__instance.damage *= YuzusQoL.PiercerDamageMultiplier.Value;
					Debug.Log((object)$"[Yuzu's QoL] Piercer beam damage: {damage} -> {__instance.damage}");
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in BuffPiercerDamage: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(Revolver))]
	public class PiercerChargePatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void FasterCharge(Revolver __instance)
		{
			try
			{
				if (YuzusQoL.PiercerChargeSpeedMultiplier == null || __instance.gunVariation != 0 || __instance.altVersion)
				{
					return;
				}
				Traverse val = Traverse.Create((object)__instance);
				if (!val.Field("pierceReady").GetValue<bool>())
				{
					float value = val.Field("pierceCharge").GetValue<float>();
					float num = 40f * (YuzusQoL.PiercerChargeSpeedMultiplier.Value - 1f) * Time.deltaTime;
					float num2 = value + num;
					val.Field("pierceCharge").SetValue((object)num2);
					if (num2 >= 100f)
					{
						val.Field("pierceCharge").SetValue((object)100f);
						val.Field("pierceReady").SetValue((object)true);
					}
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in FasterCharge: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(FireZone))]
	public class StreetcleanerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void ReduceDamage(FireZone __instance)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			try
			{
				if ((Object)(object)__instance == (Object)null)
				{
					Debug.LogWarning((object)"[Yuzu's QoL] FireZone instance is null!");
				}
				else if (YuzusQoL.StreetcleanerDamageMultiplier == null)
				{
					Debug.LogWarning((object)"[Yuzu's QoL] Config not initialized!");
				}
				else if ((int)__instance.source == 1)
				{
					int playerDamage = __instance.playerDamage;
					__instance.playerDamage = (int)((float)playerDamage * YuzusQoL.StreetcleanerDamageMultiplier.Value);
					Debug.Log((object)$"[Yuzu's QoL] Streetcleaner damage: {playerDamage} -> {__instance.playerDamage}");
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in StreetcleanerPatch: {arg}");
			}
		}
	}
}
namespace YuzusQoL.Patches.Weapons
{
	[HarmonyPatch(typeof(Explosion))]
	public class MaliciousRailcannonPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void BuffMaliciousRailcannonExplosion(Explosion __instance)
		{
			try
			{
				if (__instance.hitterWeapon == "railcannon2")
				{
					if (YuzusQoL.MaliciousRailcannonDamageMultiplier != null)
					{
						__instance.damage = Mathf.RoundToInt((float)__instance.damage * YuzusQoL.MaliciousRailcannonDamageMultiplier.Value);
					}
					if (YuzusQoL.MaliciousRailcannonExplosionRadiusMultiplier != null)
					{
						__instance.maxSize *= YuzusQoL.MaliciousRailcannonExplosionRadiusMultiplier.Value;
					}
					if (YuzusQoL.MaliciousRailcannonSelfDamage != null)
					{
						__instance.playerDamageOverride = YuzusQoL.MaliciousRailcannonSelfDamage.Value;
					}
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in BuffMaliciousRailcannon: {arg}");
			}
		}
	}
}
namespace YuzusQoL.Patches.Jackhammer
{
	[HarmonyPatch(typeof(ShotgunHammer))]
	public class JackhammerStylePatch
	{
		[HarmonyPatch("DeliverDamage")]
		[HarmonyPostfix]
		private static void BoostJackhammerStyle(ShotgunHammer __instance)
		{
			try
			{
				Traverse val = Traverse.Create((object)__instance);
				int value = val.Field("tier").GetValue<int>();
				EnemyIdentifier value2 = val.Field("hitEnemy").GetValue<EnemyIdentifier>();
				if ((Object)(object)value2 == (Object)null)
				{
					return;
				}
				if (value2.dead)
				{
					int num = 0;
					string text = "";
					switch (value)
					{
					case 2:
						num = YuzusQoL.JackhammerFullImpactStyle.Value - 240;
						text = "ultrakill.hammerhitred";
						break;
					case 1:
						num = YuzusQoL.JackhammerHeavyHitterStyle.Value - 120;
						text = "ultrakill.hammerhityellow";
						break;
					default:
						num = YuzusQoL.JackhammerBluntForceStyle.Value - 80;
						text = "ultrakill.hammerhitgreen";
						break;
					}
					if (num > 0)
					{
						MonoSingleton<StyleHUD>.Instance.AddPoints(num, text, ((Component)__instance).gameObject, value2, -1, "", "");
					}
				}
				else
				{
					int num2 = 0;
					string text2 = "";
					if (value == 2)
					{
						num2 = YuzusQoL.JackhammerHeavyHitStyle.Value - 120;
						text2 = "ultrakill.hammerhitheavy";
					}
					else
					{
						int num3 = 40 * (value + 1);
						int num4 = Mathf.RoundToInt((float)num3 * YuzusQoL.JackhammerRegularHitStyleMultiplier.Value);
						num2 = num4 - num3;
						text2 = "ultrakill.hammerhit";
					}
					if (num2 > 0)
					{
						MonoSingleton<StyleHUD>.Instance.AddPoints(num2, text2, ((Component)__instance).gameObject, value2, -1, "", "");
					}
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in JackhammerStylePatch: {arg}");
			}
		}
	}
}
namespace YuzusQoL.Patches.Bosses
{
	[HarmonyPatch(typeof(NewMovement))]
	public class GeryonDashPatch
	{
		private const string GeryonSceneName = "7f3f5eabda008e04cb2364d6f0327aa5";

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void FasterDashRegenInGeryonFight(NewMovement __instance)
		{
			//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)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (!(name != "7f3f5eabda008e04cb2364d6f0327aa5"))
				{
					Traverse val = Traverse.Create((object)__instance);
					float value = val.Field("boostCharge").GetValue<float>();
					bool value2 = val.Field("sliding").GetValue<bool>();
					bool value3 = val.Field("slowMode").GetValue<bool>();
					if (value < 300f && !value2 && !value3)
					{
						float num = 70f * Time.deltaTime * YuzusQoL.GeryonDashRegenMultiplier.Value;
						float num2 = Mathf.Min(300f, value + num);
						val.Field("boostCharge").SetValue((object)num2);
					}
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in FasterDashRegen: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(MinosPrime))]
	public class MinosPrimePatch
	{
		[HarmonyPatch("Dropkick")]
		[HarmonyPostfix]
		private static void SlowJudgement(MinosPrime __instance)
		{
			try
			{
				Traverse val = Traverse.Create((object)__instance);
				Animator value = val.Field("anim").GetValue<Animator>();
				if ((Object)(object)value != (Object)null && YuzusQoL.MinosJudgementSpeedMultiplier != null)
				{
					value.speed *= YuzusQoL.MinosJudgementSpeedMultiplier.Value;
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in SlowJudgement: {arg}");
			}
		}

		[HarmonyPatch("DropAttack")]
		[HarmonyPostfix]
		private static void SlowCrush(MinosPrime __instance)
		{
			try
			{
				Traverse val = Traverse.Create((object)__instance);
				Animator value = val.Field("anim").GetValue<Animator>();
				if ((Object)(object)value != (Object)null && YuzusQoL.MinosCrushSpeedMultiplier != null)
				{
					value.speed *= YuzusQoL.MinosCrushSpeedMultiplier.Value;
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in SlowCrush: {arg}");
			}
		}

		[HarmonyPatch("StopAction")]
		[HarmonyPrefix]
		private static void ResetAnimSpeed(MinosPrime __instance)
		{
			try
			{
				Traverse val = Traverse.Create((object)__instance);
				Animator value = val.Field("anim").GetValue<Animator>();
				if ((Object)(object)value != (Object)null)
				{
					int value2 = val.Field("difficulty").GetValue<int>();
					float speed = 1f;
					switch (value2)
					{
					case 0:
						speed = 0.8f;
						break;
					case 1:
						speed = 0.9f;
						break;
					case 2:
						speed = 1f;
						break;
					case 3:
						speed = 1f;
						break;
					case 4:
						speed = 1.125f;
						break;
					case 5:
						speed = 1.25f;
						break;
					}
					value.speed = speed;
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in ResetAnimSpeed: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(SisyphusPrime))]
	public class SisyphusPrimePatch
	{
		[HarmonyPatch("GotParried")]
		[HarmonyPrefix]
		private static void BoostParryVoice(SisyphusPrime __instance)
		{
			try
			{
				Traverse val = Traverse.Create((object)__instance);
				AudioSource value = val.Field("aud").GetValue<AudioSource>();
				if ((Object)(object)value != (Object)null)
				{
					value.volume = YuzusQoL.SisyphusParryVoiceVolume.Value;
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in SisyphusPrimePatch: {arg}");
			}
		}

		[HarmonyPatch("PlayVoice")]
		[HarmonyPostfix]
		private static void BoostVoiceVolume(SisyphusPrime __instance, AudioClip[] voice)
		{
			try
			{
				Traverse val = Traverse.Create((object)__instance);
				AudioClip[] value = val.Field("hurtVoice").GetValue<AudioClip[]>();
				AudioSource value2 = val.Field("aud").GetValue<AudioSource>();
				if ((Object)(object)value2 != (Object)null && value != null && voice == value)
				{
					value2.volume = YuzusQoL.SisyphusParryVoiceVolume.Value;
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Yuzu's QoL] Error in BoostVoiceVolume: {arg}");
			}
		}
	}
}