#define DEBUG
using System;
using System.Diagnostics;
using System.IO;
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 IL.RoR2;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using R2API;
using R2API.Utils;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Projectile;
using UnityEngine;
using UnityEngine.AddressableAssets;

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

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

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

		[Conditional("DEBUG")]
		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(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Braquen.Sticky_Tweaks", "Sticky_Tweaks", "1.0.1")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Main : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__GlobalEventManager_ProcessHitEnemy;

			public static Action<ProjectileManager, GameObject, Vector3, Quaternion, GameObject, float, float, bool, DamageColorIndex, GameObject, float, DamageTypeCombo?, DamageInfo> <1>__FireModifiedStickyBomb;

			public static Func<DamageInfo, bool> <2>__CheckHitEnemyProc;

			public static Func<float, float> <3>__InjectProcChance;
		}

		public const string PluginGUID = "Braquen.Sticky_Tweaks";

		public const string PluginAuthor = "Braquen";

		public const string PluginName = "Sticky_Tweaks";

		public const string PluginVersion = "1.0.1";

		public static PluginInfo pluginInfo;

		public static AssetBundle AssetBundle;

		public static ConfigEntry<float> Damage;

		public static ConfigEntry<float> ProcChance;

		public static ConfigEntry<float> ProcCoefficient;

		public static ConfigEntry<bool> OnHitAll;

		private static float DamageCoefficient;

		private GameObject StickyBombPrefab;

		private static ProjectileImpactExplosion StickyExplosion;

		public static ModdedProcType StickyProc = ProcTypeAPI.ReserveProcType();

		public void Awake()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			Log.Init(((BaseUnityPlugin)this).Logger);
			pluginInfo = ((BaseUnityPlugin)this).Info;
			ConfigFile val = new ConfigFile(Path.Combine(Paths.ConfigPath, "braquen-stickytweaks.cfg"), true);
			Damage = val.Bind<float>("Stats", "Damage", 1.8f, "Sticky Bomb's damage multiplier.");
			ModSettingsManager.AddOption((BaseOption)new StepSliderOption(Damage, new StepSliderConfig
			{
				min = 0.1f,
				max = 18f,
				increment = 0.05f
			}));
			ProcChance = val.Bind<float>("Stats", "Proc Chance", 5f, "Sticky Bomb's chance to proc on hit.");
			ModSettingsManager.AddOption((BaseOption)new StepSliderOption(ProcChance, new StepSliderConfig
			{
				min = 1f,
				max = 300f,
				increment = 0.5f
			}));
			ProcCoefficient = val.Bind<float>("Extra Functionality", "Proc Coefficient", 0.5f, "Sticky Bomb's proc coefficient. Set 0 to restore base game functionality.");
			ModSettingsManager.AddOption((BaseOption)new StepSliderOption(ProcCoefficient, new StepSliderConfig
			{
				min = 0f,
				max = 10f,
				increment = 0.1f
			}));
			OnHitAll = val.Bind<bool>("Extra Functionality", "Stick Anything", false, "Allows Sticky Bomb to proc when hitting anything, similar to Behemoth or Overloading Elite bombs.");
			ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(OnHitAll));
			ModSettingsManager.SetModDescription("Tweaks sticky bomb to give it more potential for synergy.");
			Sprite modIcon = Addressables.LoadAssetAsync<Sprite>((object)"RoR2/Base/StickyBomb/texStickyBombIcon.png").WaitForCompletion();
			ModSettingsManager.SetModIcon(modIcon);
			StickyBombPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/StickyBomb/StickyBomb.prefab").WaitForCompletion();
			ProjectileController component = StickyBombPrefab.GetComponent<ProjectileController>();
			component.procCoefficient = 1f;
			StickyExplosion = StickyBombPrefab.GetComponent<ProjectileImpactExplosion>();
			((ProjectileExplosion)StickyExplosion).blastProcCoefficient = ProcCoefficient.Value;
			ProcCoefficient.SettingChanged += delegate
			{
				((ProjectileExplosion)StickyExplosion).blastProcCoefficient = ProcCoefficient.Value;
			};
			DamageCoefficient = Damage.Value / 1.8f;
			Damage.SettingChanged += delegate
			{
				DamageCoefficient = Damage.Value / 1.8f;
			};
			object obj = <>O.<0>__GlobalEventManager_ProcessHitEnemy;
			if (obj == null)
			{
				Manipulator val2 = GlobalEventManager_ProcessHitEnemy;
				<>O.<0>__GlobalEventManager_ProcessHitEnemy = val2;
				obj = (object)val2;
			}
			GlobalEventManager.ProcessHitEnemy += (Manipulator)obj;
			GlobalEventManager.OnHitAllProcess += new hook_OnHitAllProcess(GlobalEventManager_OnHitAllProcess);
		}

		private static void GlobalEventManager_ProcessHitEnemy(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			Log.Debug("Changing proc chain mask");
			try
			{
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[4]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 80),
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 77),
					(Instruction x) => ILPatternMatchingExt.MatchMul(x),
					(Instruction x) => ILPatternMatchingExt.MatchLdloca(x, 84)
				});
				val.Index += 2;
				val.Remove();
				val.Emit(OpCodes.Ldarg, 1);
				val.EmitDelegate<Action<ProjectileManager, GameObject, Vector3, Quaternion, GameObject, float, float, bool, DamageColorIndex, GameObject, float, DamageTypeCombo?, DamageInfo>>((Action<ProjectileManager, GameObject, Vector3, Quaternion, GameObject, float, float, bool, DamageColorIndex, GameObject, float, DamageTypeCombo?, DamageInfo>)FireModifiedStickyBomb);
				try
				{
					ILLabel stickyConditional = null;
					val.GotoPrev((MoveType)0, new Func<Instruction, bool>[3]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 16),
						(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchBle(x, ref stickyConditional)
					});
					val.Emit(OpCodes.Ldarg, 1);
					val.EmitDelegate<Func<DamageInfo, bool>>((Func<DamageInfo, bool>)CheckHitEnemyProc);
					val.Emit(OpCodes.Brtrue, (object)stickyConditional);
					val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 5f)
					});
					val.EmitDelegate<Func<float, float>>((Func<float, float>)InjectProcChance);
				}
				catch (Exception e)
				{
					ErrorHookFailed("Check for sticky proc", e);
				}
			}
			catch (Exception e2)
			{
				ErrorHookFailed("Add Sticky to mask", e2);
			}
		}

		private static bool CheckHitEnemyProc(DamageInfo info)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return OnHitAll.Value || ProcTypeAPI.HasModdedProc(info.procChainMask, StickyProc);
		}

		private static float InjectProcChance(float ogChance)
		{
			return ProcChance.Value;
		}

		private static void FireModifiedStickyBomb(ProjectileManager instance, GameObject prefab, Vector3 pos, Quaternion rot, GameObject owner, float damage, float force, bool crit, DamageColorIndex col, GameObject target, float speedOverride, DamageTypeCombo? type, DamageInfo info)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			FireProjectileInfo val = default(FireProjectileInfo);
			val.projectilePrefab = prefab;
			val.position = pos;
			val.rotation = rot;
			val.owner = owner;
			val.damage = damage * DamageCoefficient;
			val.force = force;
			val.crit = crit;
			val.damageColorIndex = col;
			val.target = target;
			((FireProjectileInfo)(ref val)).speedOverride = speedOverride;
			((FireProjectileInfo)(ref val)).fuseOverride = -1f;
			val.damageTypeOverride = type;
			val.procChainMask = info.procChainMask;
			ProcTypeAPI.AddModdedProc(ref val.procChainMask, StickyProc);
			FireProjectileInfo val2 = val;
			instance.FireProjectile(val2);
		}

		internal static void ErrorHookFailed(string name, Exception e)
		{
			Log.Error(name + " hook failed: " + e.Message);
		}

		private void GlobalEventManager_OnHitAllProcess(orig_OnHitAllProcess orig, GlobalEventManager self, DamageInfo damageInfo, GameObject hitObject)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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_016e: 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_019d: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, damageInfo, hitObject);
			if (damageInfo.procCoefficient == 0f || damageInfo.rejected || !OnHitAll.Value || !Object.op_Implicit((Object)(object)damageInfo.attacker))
			{
				return;
			}
			CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			CharacterMaster master = component.master;
			if (!Object.op_Implicit((Object)(object)master))
			{
				return;
			}
			Inventory inventory = master.inventory;
			if (!Object.op_Implicit((Object)(object)master.inventory))
			{
				return;
			}
			CharacterBody component2 = hitObject.GetComponent<CharacterBody>();
			if (!ProcTypeAPI.HasModdedProc(damageInfo.procChainMask, StickyProc))
			{
				int itemCount = inventory.GetItemCount(Items.StickyBomb);
				if (itemCount > 0 && Util.CheckRoll(ProcChance.Value * (float)itemCount * damageInfo.procCoefficient, master))
				{
					Vector3 val = damageInfo.position + 0.1f * Vector3.upVector;
					Vector3 val2 = (Object.op_Implicit((Object)(object)component2) ? (component2.corePosition - val) : Vector3.zero);
					float magnitude = ((Vector3)(ref val2)).magnitude;
					Quaternion rot = ((magnitude != 0f) ? Util.QuaternionSafeLookRotation(val2) : Random.rotationUniform);
					float num = 1.8f;
					float damage = Util.OnHitProcDamage(damageInfo.damage, component.damage, num);
					FireModifiedStickyBomb(ProjectileManager.instance, LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/StickyBomb"), val, rot, damageInfo.attacker, damage, 100f, damageInfo.crit, (DamageColorIndex)3, null, -1f, null, damageInfo);
				}
			}
		}
	}
}