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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("HowToFishMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("HowToFishMod")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("54fa6bec-07e7-427d-954f-162d98439276")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace HowToFishMod;

[BepInPlugin("com.peep.howtofish.killscorebonuses", "Kill Score Bonuses", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	public static ConfigEntry<bool> EnableAlways360;

	public static ConfigEntry<bool> EnableAlwaysDogfight;

	public static ConfigEntry<bool> EnableAlwaysEndangered;

	public static ConfigEntry<bool> EnableAlwaysFinally;

	public static ConfigEntry<bool> EnableAlwaysHeadshot;

	public static ConfigEntry<bool> EnableAlwaysImpressive;

	public static ConfigEntry<bool> EnableAlwaysKillsteal;

	public static ConfigEntry<bool> EnableAlwaysExplosion;

	public static ConfigEntry<bool> EnableAlwaysLastBullet;

	public static ConfigEntry<bool> EnableAlwaysLongshot;

	public static ConfigEntry<bool> EnableAlwaysPentakill;

	public static ConfigEntry<bool> EnableAlwaysNoob;

	public static ConfigEntry<bool> EnableAlwaysOneShotOneKill;

	public static ConfigEntry<bool> EnableAlwaysOverkill;

	public static ConfigEntry<bool> EnableAlwaysPointBlank;

	public static ConfigEntry<bool> EnableAlwaysNoScope;

	private void Awake()
	{
		//IL_0206: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Expected O, but got Unknown
		EnableAlways360 = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlways360", true, "Guarantees 360 bonus.");
		EnableAlwaysDogfight = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysDogfight", true, "Guarantees Dogfight aerial bonus.");
		EnableAlwaysEndangered = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysEndangered", true, "Guarantees Endangered bonus.");
		EnableAlwaysFinally = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysFinally", true, "Guarantees Finally bonus.");
		EnableAlwaysHeadshot = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysHeadshot", true, "Guarantees Headshot bonus.");
		EnableAlwaysImpressive = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysImpressive", true, "Guarantees Impressive bonus.");
		EnableAlwaysKillsteal = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysKillsteal", true, "Guarantees Killsteal bonus.");
		EnableAlwaysExplosion = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysExplosion", true, "Guarantees Explosion bonus.");
		EnableAlwaysLastBullet = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysLastBullet", true, "Guarantees LastBullet bonus.");
		EnableAlwaysLongshot = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysLongshot", true, "Guarantees Longshot bonus.");
		EnableAlwaysPentakill = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysPentakill", true, "Guarantees Pentakill bonus.");
		EnableAlwaysNoob = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysNoob", true, "Guarantees Noob bonus.");
		EnableAlwaysOneShotOneKill = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysOneShotOneKill", true, "Guarantees OneShotOneKill bonus.");
		EnableAlwaysOverkill = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysOverkill", true, "Guarantees Overkill bonus.");
		EnableAlwaysPointBlank = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysPointBlank", true, "Guarantees PointBlank bonus.");
		EnableAlwaysNoScope = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableAlwaysNoScope", true, "Guarantees NoScope bonus.");
		Harmony val = new Harmony("com.peep.howtofish.killscorebonuses");
		val.PatchAll(Assembly.GetExecutingAssembly());
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Always 360 Bonus Mod Loaded!");
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "Check360")]
public class Patch_KillScoreCalculator_Check360
{
	[HarmonyPrefix]
	private static bool Prefix(ref bool ____did360, ref List<Bonus> ____bonuses)
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlways360.Value)
		{
			return true;
		}
		____did360 = true;
		____bonuses.Add(new Bonus(LocalizationManager.ThreeSixtyLocalized.GetLocalizedString(), 1.5f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckAerials")]
public class Patch_KillScoreCalculator_CheckAerials
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysDogfight.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.DogfightLocalized.GetLocalizedString(), 1.5f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckEndangered")]
public class Patch_KillScoreCalculator_CheckEndangered
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysEndangered.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.EndangeredLocalized.GetLocalizedString(), 1.25f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckFinally")]
public class Patch_KillScoreCalculator_CheckFinally
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysFinally.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.FinallyLocalized.GetLocalizedString(), 1.1f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckHeadshot")]
public class Patch_KillScoreCalculator_CheckHeadshot
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysHeadshot.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.HeadshotLocalized.GetLocalizedString(), 1.25f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckImpressive")]
public class Patch_KillScoreCalculator_CheckImpressive
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysImpressive.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.ImpressiveLocalized.GetLocalizedString(), 2f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckKillsteal")]
public class Patch_KillScoreCalculator_CheckKillsteal
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysKillsteal.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.KillstealLocalized.GetLocalizedString(), 1.3f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckKillType")]
public class Patch_KillScoreCalculator_CheckExplosion
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysExplosion.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.ExplosionLocalized.GetLocalizedString(), 1.25f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckLastBullet")]
public class Patch_KillScoreCalculator_CheckLastBullet
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysLastBullet.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.LastBulletLocalized.GetLocalizedString(), 1.25f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckLongshot")]
public class Patch_KillScoreCalculator_CheckLongshot
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysLongshot.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.LongshotLocalized.GetLocalizedString(), 1.3f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckMultikill")]
public class Patch_KillScoreCalculator_CheckMultikill
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysPentakill.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.PentaKillLocalized.GetLocalizedString(), Mathf.Lerp(1f, 1.5f, 0.5f)));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckNoob")]
public class Patch_KillScoreCalculator_CheckNoob
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysNoob.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.NoobKillLocalized.GetLocalizedString(), 1.01f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckOneShotOneKill")]
public class Patch_KillScoreCalculator_CheckOneShotOneKill
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysOneShotOneKill.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.OneShotOneKillLocalized.GetLocalizedString(), 1.25f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckOverkill")]
public class Patch_KillScoreCalculator_CheckOverkill
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysOverkill.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.OverkillLocalized.GetLocalizedString(), 1.25f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckPointBlank")]
public class Patch_KillScoreCalculator_CheckPointBlank
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.EnableAlwaysPointBlank.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.PointBlankLocalized.GetLocalizedString(), 1.1f));
		return false;
	}
}
[HarmonyPatch(typeof(KillScoreCalculator), "CheckScope")]
public class Patch_KillScoreCalculator_CheckNoScope
{
	[HarmonyPrefix]
	private static bool Prefix(ref List<Bonus> ____bonuses)
	{
		//IL_0028: 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)
		if (!Plugin.EnableAlwaysNoScope.Value)
		{
			return true;
		}
		____bonuses.Add(new Bonus(LocalizationManager.NoScopeLocalized.GetLocalizedString(), 1.2f));
		____bonuses.Add(new Bonus(LocalizationManager.QuickScopeLocalized.GetLocalizedString(), 1.1f));
		return false;
	}
}