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.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Gear;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("CasualAmmo")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+09d2c2ea46df3a13308590212e56ee5e753f33be")]
[assembly: AssemblyProduct("CasualAmmo")]
[assembly: AssemblyTitle("CasualAmmo")]
[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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 CasualAmmo
{
	[BepInPlugin("com.privatecoop.gtfo.casualammo", "Casual Ammo", "1.0.13")]
	public sealed class Plugin : BasePlugin
	{
		public const string PluginGuid = "com.privatecoop.gtfo.casualammo";

		public const string PluginName = "Casual Ammo";

		public const string PluginVersion = "1.0.13";

		private static readonly Harmony Harmony = new Harmony("com.privatecoop.gtfo.casualammo");

		internal static ManualLogSource Logger = null;

		internal static ConfigEntry<bool> EnableMod = null;

		internal static ConfigEntry<AmmoRestoreMode> RestoreMode = null;

		internal static ConfigEntry<float> RestoreMultiplier = null;

		internal static ConfigEntry<float> MunitionPackCharges = null;

		internal static ConfigEntry<bool> InfiniteReserveAmmo = null;

		internal static ConfigEntry<bool> PrivateLobbyWarning = null;

		internal static bool IsEnabled => EnableMod?.Value ?? false;

		internal static float DesiredPackPercent => Math.Clamp(MunitionPackCharges.Value, 0f, 100f);

		public override void Load()
		{
			Logger = ((BasePlugin)this).Log;
			BindConfig();
			LogStartupConfiguration();
			if (!EnableMod.Value)
			{
				Logger.LogInfo((object)"EnableMod is false; Casual Ammo patches were not applied.");
				return;
			}
			Harmony.PatchAll(typeof(Plugin).Assembly);
			Logger.LogInfo((object)"Harmony patches applied.");
		}

		public override bool Unload()
		{
			Harmony.UnpatchSelf();
			return true;
		}

		private void BindConfig()
		{
			EnableMod = ((BasePlugin)this).Config.Bind<bool>("General", "EnableMod", true, "Enables or disables all Casual Ammo changes.");
			RestoreMode = ((BasePlugin)this).Config.Bind<AmmoRestoreMode>("Ammo Restore", "AmmoRestoreMode", AmmoRestoreMode.FullRestore, "FullRestore, Multiplier, or Disabled.");
			RestoreMultiplier = ((BasePlugin)this).Config.Bind<float>("Ammo Restore", "RestoreMultiplier", 10f, "Multiplier applied to munitions pack ammo restore when AmmoRestoreMode is Multiplier.");
			MunitionPackCharges = ((BasePlugin)this).Config.Bind<float>("Munitions Packs", "MunitionPackCharges", 999f, "Minimum ammo capacity shown/stored on weapon munitions packs.");
			InfiniteReserveAmmo = ((BasePlugin)this).Config.Bind<bool>("Reserve Ammo", "InfiniteReserveAmmo", false, "When enabled, weapon reserve ammo storage is refilled to a very high cap after setup.");
			PrivateLobbyWarning = ((BasePlugin)this).Config.Bind<bool>("Safety", "PrivateLobbyWarning", true, "Logs a private-lobby-only warning on startup.");
		}

		private static void LogStartupConfiguration()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			if (PrivateLobbyWarning.Value)
			{
				Logger.LogWarning((object)"Casual Ammo is intended for private cooperative lobbies only. Do not use it in public matchmaking.");
			}
			ManualLogSource logger = Logger;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(12, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("EnableMod = ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(EnableMod.Value);
			}
			logger.LogInfo(val);
			ManualLogSource logger2 = Logger;
			val = new BepInExInfoLogInterpolatedStringHandler(18, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("AmmoRestoreMode = ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AmmoRestoreMode>(RestoreMode.Value);
			}
			logger2.LogInfo(val);
			ManualLogSource logger3 = Logger;
			val = new BepInExInfoLogInterpolatedStringHandler(20, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("RestoreMultiplier = ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(RestoreMultiplier.Value);
			}
			logger3.LogInfo(val);
			ManualLogSource logger4 = Logger;
			val = new BepInExInfoLogInterpolatedStringHandler(49, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("MunitionPackCharges = ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(MunitionPackCharges.Value);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (resolved pack percent = ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(DesiredPackPercent);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
			}
			logger4.LogInfo(val);
			ManualLogSource logger5 = Logger;
			val = new BepInExInfoLogInterpolatedStringHandler(22, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("InfiniteReserveAmmo = ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(InfiniteReserveAmmo.Value);
			}
			logger5.LogInfo(val);
			if (EnableMod.Value)
			{
				Logger.LogInfo((object)"Patch plan: PlayerAgent.GiveAmmoRel adjusts standard/special weapon ammo restore only; class/tool ammo is left unchanged.");
				Logger.LogInfo((object)"Patch plan: ResourcePackPickup.OnInteractionPickUp logs and tops up weapon munitions packs on pickup.");
				Logger.LogInfo((object)"Patch plan: ResourcePackPickup.UpdateAmmo keeps weapon munitions packs stocked.");
				Logger.LogInfo((object)"Patch plan: ResourcePackFirstPerson.OnWield/ApplyPack tops up the equipped weapon munitions pack.");
				Logger.LogInfo((object)"Patch plan: ResourcePackFirstPerson.ApplyPack is replaced for weapon munitions packs to grant ammo without consuming the pack.");
				Logger.LogInfo((object)"Patch plan: PUI_Inventory.SetSlotAmmo keeps the resource-pack HUD display at the configured pack percent only while a weapon munitions pack is equipped.");
				Logger.LogInfo((object)"Patch plan: PlayerAmmoStorage.UpdateAmmoInPack and InventorySlotAmmo.AddAmmo force positive standard/special weapon ammo additions to full.");
				Logger.LogInfo((object)"Patch plan: PlayerAmmoStorage.SetupAmmoType only changes reserves when InfiniteReserveAmmo is true.");
			}
		}

		internal static bool IsWeaponAmmoPack(ResourcePackPickup pack)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((Object)(object)pack != (Object)null)
			{
				return (int)pack.m_packType == 1;
			}
			return false;
		}

		internal static bool IsWeaponAmmo(AmmoType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)type <= 1)
			{
				return true;
			}
			return false;
		}
	}
	public enum AmmoRestoreMode
	{
		FullRestore,
		Multiplier,
		Disabled
	}
	[HarmonyPatch(typeof(PlayerAgent), "GiveAmmoRel")]
	internal static class PlayerAgentGiveAmmoRelPatch
	{
		private static void Prefix(ref float ammoStandardRel, ref float ammoSpecialRel, ref float ammoClassRel)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			if (!Plugin.IsEnabled || Plugin.RestoreMode.Value == AmmoRestoreMode.Disabled)
			{
				return;
			}
			bool flag = default(bool);
			switch (Plugin.RestoreMode.Value)
			{
			case AmmoRestoreMode.FullRestore:
			{
				ManualLogSource logger2 = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(85, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo GiveAmmoRel hook: restore standard/special ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammoStandardRel, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("/");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammoSpecialRel, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -> 1/1; class/tool remains ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammoClassRel, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				logger2.LogWarning(val);
				if (ammoStandardRel > 0f)
				{
					ammoStandardRel = 1f;
				}
				if (ammoSpecialRel > 0f)
				{
					ammoSpecialRel = 1f;
				}
				break;
			}
			case AmmoRestoreMode.Multiplier:
			{
				float num = Math.Max(0f, Plugin.RestoreMultiplier.Value);
				ManualLogSource logger = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(81, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo GiveAmmoRel hook: restore standard/special ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammoStandardRel, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("/");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammoSpecialRel, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" x ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; class/tool remains ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammoClassRel, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				logger.LogWarning(val);
				if (ammoStandardRel > 0f)
				{
					ammoStandardRel *= num;
				}
				if (ammoSpecialRel > 0f)
				{
					ammoSpecialRel *= num;
				}
				break;
			}
			}
		}
	}
	[HarmonyPatch]
	internal static class ResourcePackPickupOnInteractionPickUpPatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(ResourcePackPickup), "OnInteractionPickUp", new Type[1] { typeof(PlayerAgent) }, (Type[])null);
		}

		private static void Prefix(ResourcePackPickup __instance, PlayerAgent player)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsEnabled || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			eResourceContainerSpawnType packType = __instance.m_packType;
			float num = -1f;
			bool flag = default(bool);
			try
			{
				num = ((Item)__instance).Get_pItemData().custom.ammo;
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(68, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Ammo pack pickup detected, but current pack ammo could not be read: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				logger.LogWarning(val);
			}
			if ((int)packType == 1)
			{
				float num2 = Math.Max(num, Plugin.DesiredPackPercent);
				__instance.UpdateAmmo(num2);
				ManualLogSource logger2 = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(77, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo pickup hook: weapon munitions pack picked up by ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(GetPlayerLabel(player));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(". Pack ammo ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num, "0.##");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -> ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num2, "0.##");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				logger2.LogWarning(val);
			}
			else
			{
				ManualLogSource logger3 = Plugin.Logger;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(78, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Casual Ammo pickup hook: non-weapon resource pack picked up by ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(GetPlayerLabel(player));
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(". Type=");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<eResourceContainerSpawnType>(packType);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", ammo=");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<float>(num, "0.##");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(".");
				}
				logger3.LogInfo(val2);
			}
		}

		private static string GetPlayerLabel(PlayerAgent player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "unknown player";
			}
			try
			{
				SNet_Player owner = player.Owner;
				return ((owner != null) ? owner.NickName : null) ?? "unknown player";
			}
			catch
			{
				return "unknown player";
			}
		}
	}
	[HarmonyPatch(typeof(ResourcePackFirstPerson), "OnWield")]
	internal static class ResourcePackFirstPersonOnWieldPatch
	{
		private static void Postfix(ResourcePackFirstPerson __instance)
		{
			ResourcePackHudState.UpdateEquippedPack(__instance);
			EquippedResourcePackAmmo.TryTopUp(__instance, "OnWield", forceWrite: true);
		}
	}
	[HarmonyPatch]
	internal static class ResourcePackFirstPersonApplyPackPatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(ResourcePackFirstPerson), "ApplyPack", (Type[])null, (Type[])null);
		}

		private static bool Prefix(ResourcePackFirstPerson __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			EquippedResourcePackAmmo.TryTopUp(__instance, "ApplyPack prefix", forceWrite: true);
			if (!Plugin.IsEnabled || (Object)(object)__instance == (Object)null || (int)__instance.m_packType != 1)
			{
				return true;
			}
			iResourcePackReceiver val = __instance.m_actionReceiver ?? __instance.m_lastActionReceiver;
			if (val == null)
			{
				Plugin.Logger.LogWarning((object)"Casual Ammo non-consuming ApplyPack: no action receiver found; allowing original ApplyPack.");
				return true;
			}
			PlayerAgent owner = ((Item)__instance).Owner;
			Plugin.Logger.LogWarning((object)"Casual Ammo non-consuming ApplyPack: granting full standard/special ammo through the resource receiver and skipping original pack consumption.");
			val.GiveAmmoRel(owner, 1f, 1f, 0f);
			EquippedResourcePackAmmo.TryTopUp(__instance, "ApplyPack manual grant", forceWrite: true);
			return false;
		}

		private static void Postfix(ResourcePackFirstPerson __instance)
		{
			EquippedResourcePackAmmo.TryTopUp(__instance, "ApplyPack postfix", forceWrite: true);
		}
	}
	internal static class EquippedResourcePackAmmo
	{
		internal static void TryTopUp(ResourcePackFirstPerson pack, string reason, bool forceWrite = false)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			if (!Plugin.IsEnabled || (Object)(object)pack == (Object)null || (int)pack.m_packType != 1)
			{
				return;
			}
			bool flag = default(bool);
			try
			{
				pItemData_Custom customData = ((Item)pack).GetCustomData();
				float ammo = customData.ammo;
				float num = Math.Max(ammo, Plugin.DesiredPackPercent);
				if (forceWrite || num > ammo)
				{
					customData.ammo = num;
					((Item)pack).SetCustomData(customData, true);
				}
				if (ammo < num)
				{
					ManualLogSource logger = Plugin.Logger;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(67, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo equipped pack hook (");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(reason);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("): weapon munitions pack ammo ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammo, "0.##");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -> ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num, "0.##");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
					}
					logger.LogWarning(val);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(42, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo equipped pack hook (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(reason);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				logger2.LogWarning(val);
			}
		}
	}
	internal static class ResourcePackHudState
	{
		internal static bool EquippedPackIsWeaponAmmo { get; private set; }

		internal static void UpdateEquippedPack(ResourcePackFirstPerson pack)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			EquippedPackIsWeaponAmmo = Plugin.IsEnabled && (Object)(object)pack != (Object)null && (int)pack.m_packType == 1;
		}
	}
	[HarmonyPatch(typeof(ResourcePackPickup), "UpdateAmmo")]
	internal static class ResourcePackPickupUpdateAmmoPatch
	{
		private static void Prefix(ResourcePackPickup __instance, ref float ammo)
		{
			if (Plugin.IsEnabled && Plugin.IsWeaponAmmoPack(__instance))
			{
				ammo = Math.Max(ammo, Plugin.DesiredPackPercent);
			}
		}
	}
	[HarmonyPatch(typeof(PUI_Inventory), "SetSlotAmmo")]
	internal static class PuiInventorySetSlotAmmoPatch
	{
		private static void Prefix(InventorySlot slot, ref int clipAbs, ref int inPackAbs, ref float inPackRel)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			if (Plugin.IsEnabled && (int)slot == 4 && ResourcePackHudState.EquippedPackIsWeaponAmmo)
			{
				float desiredPackPercent = Plugin.DesiredPackPercent;
				inPackAbs = Math.Max(inPackAbs, (int)Math.Round(desiredPackPercent));
				inPackRel = Math.Max(inPackRel, desiredPackPercent / 100f);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAmmoStorage), "SetupAmmoType")]
	internal static class PlayerAmmoStorageSetupAmmoTypePatch
	{
		private const float ReserveCap = 999f;

		private static void Postfix(PlayerAmmoStorage __instance, AmmoType type)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.IsEnabled && Plugin.InfiniteReserveAmmo.Value && Plugin.IsWeaponAmmo(type))
			{
				InventorySlotAmmo inventorySlotAmmo = __instance.GetInventorySlotAmmo(type);
				if (inventorySlotAmmo != null)
				{
					inventorySlotAmmo.AmmoMaxCap = Math.Max(inventorySlotAmmo.AmmoMaxCap, 999f);
					inventorySlotAmmo.AmmoInPack = inventorySlotAmmo.AmmoMaxCap;
					__instance.UpdateSlotAmmoUI(inventorySlotAmmo, 0);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAmmoStorage), "UpdateAmmoInPack")]
	internal static class PlayerAmmoStorageUpdateAmmoInPackPatch
	{
		private static void Prefix(PlayerAmmoStorage __instance, AmmoType ammoType, ref float delta)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (ShouldForceFull(ammoType, delta))
			{
				float num = SafeGetAmmo(__instance, ammoType);
				delta = 1f;
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(97, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo storage hook: UpdateAmmoInPack(");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AmmoType>(ammoType);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") positive delta detected. Before=");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(num, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", forcing delta to ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(delta, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				logger.LogWarning(val);
			}
		}

		private static void Postfix(PlayerAmmoStorage __instance, AmmoType ammoType, float delta)
		{
			//IL_0000: 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)
			if (ShouldForceFull(ammoType, delta))
			{
				ForceStorageFull(__instance, ammoType, "UpdateAmmoInPack");
			}
		}

		private static bool ShouldForceFull(AmmoType ammoType, float delta)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.IsEnabled && Plugin.RestoreMode.Value == AmmoRestoreMode.FullRestore && Plugin.IsWeaponAmmo(ammoType))
			{
				return delta > 0f;
			}
			return false;
		}

		private static float SafeGetAmmo(PlayerAmmoStorage storage, AmmoType ammoType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return storage.GetAmmoInPack(ammoType);
			}
			catch
			{
				return -1f;
			}
		}

		internal static void ForceStorageFull(PlayerAmmoStorage storage, AmmoType ammoType, string reason)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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)
			bool flag = default(bool);
			try
			{
				InventorySlotAmmo inventorySlotAmmo = storage.GetInventorySlotAmmo(ammoType);
				BepInExWarningLogInterpolatedStringHandler val;
				if (inventorySlotAmmo == null)
				{
					ManualLogSource logger = Plugin.Logger;
					val = new BepInExWarningLogInterpolatedStringHandler(53, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo storage hook (");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(reason);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("): no slot ammo found for ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AmmoType>(ammoType);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
					}
					logger.LogWarning(val);
					return;
				}
				float ammoInPack = inventorySlotAmmo.AmmoInPack;
				inventorySlotAmmo.AmmoInPack = Math.Max(inventorySlotAmmo.AmmoInPack, inventorySlotAmmo.AmmoMaxCap);
				storage.UpdateSlotAmmoUI(inventorySlotAmmo, 0);
				ManualLogSource logger2 = Plugin.Logger;
				val = new BepInExWarningLogInterpolatedStringHandler(47, 5, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo storage hook (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(reason);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("): ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AmmoType>(ammoType);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ammo ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammoInPack, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -> ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(inventorySlotAmmo.AmmoInPack, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" / cap ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(inventorySlotAmmo.AmmoMaxCap, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				logger2.LogWarning(val);
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(41, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo storage hook (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(reason);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") failed for ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AmmoType>(ammoType);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				logger3.LogWarning(val);
			}
		}
	}
	[HarmonyPatch(typeof(InventorySlotAmmo), "AddAmmo")]
	internal static class InventorySlotAmmoAddAmmoPatch
	{
		private static void Postfix(InventorySlotAmmo __instance, float ammoAmount)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.IsEnabled && Plugin.RestoreMode.Value == AmmoRestoreMode.FullRestore && __instance != null && Plugin.IsWeaponAmmo(__instance.AmmoType) && !(ammoAmount <= 0f))
			{
				float ammoInPack = __instance.AmmoInPack;
				__instance.AmmoInPack = Math.Max(__instance.AmmoInPack, __instance.AmmoMaxCap);
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(54, 5, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Casual Ammo slot hook: AddAmmo(");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AmmoType>(__instance.AmmoType);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammoAmount, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") forced ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(ammoInPack, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -> ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(__instance.AmmoInPack, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" / cap ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(__instance.AmmoMaxCap, "0.###");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
				}
				logger.LogWarning(val);
			}
		}
	}
}