using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.Loader;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using On.EntityStates;
using On.EntityStates.Loader;
using On.RoR2;
using R2API;
using RoR2;
using RoR2.Projectile;
using RoR2.Skills;
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.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("HIFULoaderTweaks")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("HIFULoaderTweaks")]
[assembly: AssemblyTitle("HIFULoaderTweaks")]
[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 HIFULoaderTweaks
{
	public class ConfigManager
	{
		internal static bool ConfigChanged;

		internal static bool VersionChanged;

		public static T HandleConfig<T>(ConfigEntryBase entry, ConfigFile config, string name)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			MethodInfo methodInfo = (from x in typeof(ConfigFile).GetMethods()
				where x.Name == "Bind"
				select x).First();
			methodInfo = methodInfo.MakeGenericMethod(typeof(T));
			object[] parameters = new object[3]
			{
				(object)new ConfigDefinition(Regex.Replace(config.ConfigFilePath, "\\W", "") + " : " + entry.Definition.Section, name),
				entry.DefaultValue,
				(object)new ConfigDescription(entry.Description.Description, (AcceptableValueBase)null, Array.Empty<object>())
			};
			ConfigEntryBase val = (ConfigEntryBase)methodInfo.Invoke(config, parameters);
			if (Main._preVersioning)
			{
				entry.BoxedValue = entry.DefaultValue;
			}
			if (!ConfigEqual(val.DefaultValue, val.BoxedValue) && VersionChanged)
			{
				entry.BoxedValue = entry.DefaultValue;
				val.BoxedValue = val.DefaultValue;
			}
			return default(T);
		}

		private static bool ConfigEqual(object a, object b)
		{
			if (a.Equals(b))
			{
				return true;
			}
			if (float.TryParse(a.ToString(), out var result) && float.TryParse(b.ToString(), out var result2) && (double)Mathf.Abs(result - result2) < 0.0001)
			{
				return true;
			}
			return false;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("HIFU.HIFULoaderTweaks", "HIFULoaderTweaks", "1.1.5")]
	public class Main : BaseUnityPlugin
	{
		public const string PluginGUID = "HIFU.HIFULoaderTweaks";

		public const string PluginAuthor = "HIFU";

		public const string PluginName = "HIFULoaderTweaks";

		public const string PluginVersion = "1.1.5";

		public static ConfigFile HLTConfig;

		public static ConfigFile HLTBackupConfig;

		public static ManualLogSource HLTLogger;

		public static bool _preVersioning;

		public static ConfigEntry<bool> enableAutoConfig { get; set; }

		public static ConfigEntry<string> latestVersion { get; set; }

		public void Awake()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			HLTLogger = ((BaseUnityPlugin)this).Logger;
			HLTConfig = ((BaseUnityPlugin)this).Config;
			HLTBackupConfig = new ConfigFile(Paths.ConfigPath + "\\HIFU.HIFULoaderTweaks.Backup.cfg", true);
			HLTBackupConfig.Bind<string>(": DO NOT MODIFY THIS FILES CONTENTS :", ": DO NOT MODIFY THIS FILES CONTENTS :", ": DO NOT MODIFY THIS FILES CONTENTS :", ": DO NOT MODIFY THIS FILES CONTENTS :");
			enableAutoConfig = HLTConfig.Bind<bool>("Config", "Enable Auto Config Sync", true, "Disabling this would stop HIFULoaderTweaks from syncing config whenever a new version is found.");
			_preVersioning = !((Dictionary<ConfigDefinition, string>)AccessTools.DeclaredPropertyGetter(typeof(ConfigFile), "OrphanedEntries").Invoke(HLTConfig, null)).Keys.Any((ConfigDefinition x) => x.Key == "Latest Version");
			latestVersion = HLTConfig.Bind<string>("Config", "Latest Version", "1.1.5", "DO NOT CHANGE THIS");
			if (enableAutoConfig.Value && (_preVersioning || latestVersion.Value != "1.1.5"))
			{
				latestVersion.Value = "1.1.5";
				ConfigManager.VersionChanged = true;
				HLTLogger.LogInfo((object)"Config Autosync Enabled.");
			}
			IEnumerable<Type> enumerable = from type in Assembly.GetExecutingAssembly().GetTypes()
				where !type.IsAbstract && type.IsSubclassOf(typeof(TweakBase))
				select type;
			HLTLogger.LogInfo((object)"==+----------------==TWEAKS==----------------+==");
			foreach (Type item in enumerable)
			{
				TweakBase tweakBase = (TweakBase)Activator.CreateInstance(item);
				if (ValidateTweak(tweakBase))
				{
					tweakBase.Init();
				}
			}
			IEnumerable<Type> enumerable2 = from type in Assembly.GetExecutingAssembly().GetTypes()
				where !type.IsAbstract && type.IsSubclassOf(typeof(MiscBase))
				select type;
			HLTLogger.LogInfo((object)"==+----------------==MISC==----------------+==");
			foreach (Type item2 in enumerable2)
			{
				MiscBase miscBase = (MiscBase)Activator.CreateInstance(item2);
				if (ValidateMisc(miscBase))
				{
					miscBase.Init();
				}
			}
		}

		public bool ValidateTweak(TweakBase tb)
		{
			if (tb.isEnabled && ((BaseUnityPlugin)this).Config.Bind<bool>(tb.Name, "Enable?", true, "Vanilla is false").Value)
			{
				return true;
			}
			return false;
		}

		public bool ValidateMisc(MiscBase mb)
		{
			if (mb.isEnabled && ((BaseUnityPlugin)this).Config.Bind<bool>(mb.Name, "Enable?", true, "Vanilla is false").Value)
			{
				return true;
			}
			return false;
		}

		private void PeripheryMyBeloved()
		{
		}
	}
	public abstract class MiscBase
	{
		public abstract string Name { get; }

		public virtual bool isEnabled { get; } = true;


		public T ConfigOption<T>(T value, string name, string description)
		{
			ConfigEntry<T> val = Main.HLTConfig.Bind<T>(Name, name, value, description);
			ConfigManager.HandleConfig<T>((ConfigEntryBase)(object)val, Main.HLTBackupConfig, name);
			return val.Value;
		}

		public abstract void Hooks();

		public string d(float f)
		{
			return f * 100f + "%";
		}

		public virtual void Init()
		{
			Hooks();
			Main.HLTLogger.LogInfo((object)("Added " + Name));
		}
	}
	public abstract class MiscBase<T> : MiscBase where T : MiscBase<T>
	{
		public static T instance { get; set; }

		public MiscBase()
		{
			if (instance != null)
			{
				throw new InvalidOperationException("Singleton class " + typeof(T).Name + " was instantiated twice");
			}
			instance = this as T;
		}
	}
	public abstract class TweakBase
	{
		public abstract string Name { get; }

		public abstract string SkillToken { get; }

		public abstract string DescText { get; }

		public virtual bool isEnabled { get; } = true;


		public T ConfigOption<T>(T value, string name, string description)
		{
			ConfigEntry<T> val = Main.HLTConfig.Bind<T>(Name, name, value, description);
			ConfigManager.HandleConfig<T>((ConfigEntryBase)(object)val, Main.HLTBackupConfig, name);
			return val.Value;
		}

		public abstract void Hooks();

		public string d(float f)
		{
			return f * 100f + "%";
		}

		public virtual void Init()
		{
			Hooks();
			string text = "LOADER_" + SkillToken.ToUpper() + "_DESCRIPTION";
			LanguageAPI.Add(text, DescText);
			Main.HLTLogger.LogInfo((object)("Added " + Name));
		}
	}
	public abstract class TweakBase<T> : TweakBase where T : TweakBase<T>
	{
		public static T instance { get; set; }

		public TweakBase()
		{
			if (instance != null)
			{
				throw new InvalidOperationException("Singleton class " + typeof(T).Name + " was instantiated twice");
			}
			instance = this as T;
		}
	}
}
namespace HIFULoaderTweaks.Skills
{
	public class ChargedGauntlet : TweakBase
	{
		public static float minDamage;

		public static float maxDamage;

		public static float chargeRate;

		public static float speedCoeff;

		public static float cooldown;

		public static bool formula;

		public override string Name => ": Utility : Charged Gauntlet";

		public override string SkillToken => "utility";

		public override string DescText => "<style=cIsUtility>Heavy</style>. Charge up a <style=cIsUtility>piercing</style> punch for <style=cIsDamage>" + d(minDamage) + "-" + d(maxDamage) + " damage</style>.";

		public override void Init()
		{
			minDamage = ConfigOption(5f, "Minimum Damage", "Decimal. Vanilla is ???");
			maxDamage = ConfigOption(18f, "Maximum Damage", "Decimal. Vanilla is ???");
			chargeRate = ConfigOption(2f, "Charge Duration", "Vanilla is 2.5");
			speedCoeff = ConfigOption(0.45f, "Speed Coefficient", "Decimal. Vanilla is 0.3");
			cooldown = ConfigOption(5f, "Cooldown", "Vanilla is 5");
			formula = ConfigOption(value: true, "Damage Formula", "Damage based on total charge, MinDamage and MaxDamage + SpeedCoeff * (Current velocity - 20~90, depending on total charge)");
			base.Init();
		}

		public override void Hooks()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			BaseChargeFist.OnEnter += new hook_OnEnter(BaseChargeFist_OnEnter);
			BaseSwingChargedFist.OnEnter += new hook_OnEnter(BaseSwingChargedFist_OnEnter);
			Changes();
		}

		private void BaseSwingChargedFist_OnEnter(orig_OnEnter orig, BaseSwingChargedFist self)
		{
			if (self is SwingChargedFist)
			{
				BaseSwingChargedFist.velocityDamageCoefficient = speedCoeff;
				orig.Invoke(self);
				self.bonusDamage -= BaseSwingChargedFist.velocityDamageCoefficient * ((BaseState)self).damageStat * Mathf.Lerp(self.minLungeSpeed, self.maxLungeSpeed, self.charge);
				((BasicMeleeAttack)self).damageCoefficient = Mathf.Lerp(minDamage, maxDamage, self.charge);
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private void BaseChargeFist_OnEnter(orig_OnEnter orig, BaseChargeFist self)
		{
			if (self is ChargeFist)
			{
				self.baseChargeDuration = chargeRate;
			}
			orig.Invoke(self);
		}

		private void Changes()
		{
			//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)
			SteppedSkillDef val = Addressables.LoadAssetAsync<SteppedSkillDef>((object)"RoR2/Base/Loader/ChargeFist.asset").WaitForCompletion();
			((SkillDef)val).baseRechargeInterval = cooldown;
		}
	}
	public class GrappleFist : TweakBase
	{
		public static float cooldown;

		public static float range;

		public override string Name => ": Secondary : Grapple Fist";

		public override string SkillToken => "secondary";

		public override string DescText => "Fire your gauntlet forward, <style=cIsUtility>pulling</style> you to the target.";

		public override void Init()
		{
			cooldown = ConfigOption(5f, "Cooldown", "Vanilla is 5");
			range = ConfigOption(80f, "Max Range", "Vanilla is 80");
			base.Init();
		}

		public override void Hooks()
		{
			Changes();
		}

		private void Changes()
		{
			//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)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			SkillDef val = Addressables.LoadAssetAsync<SkillDef>((object)"RoR2/Base/Loader/FireHook.asset").WaitForCompletion();
			val.baseRechargeInterval = cooldown;
			GameObject val2 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Loader/LoaderHook.prefab").WaitForCompletion();
			ProjectileGrappleController component = val2.GetComponent<ProjectileGrappleController>();
			component.maxTravelDistance = range;
		}
	}
	public class Knuckleboom : TweakBase
	{
		public static float damage;

		public static float fireRate;

		public static float burstDamage;

		public static float burstAoE;

		public static float barrierGain;

		public override string Name => ": Primary : Knuckleboom";

		public override string SkillToken => "primary";

		public override string DescText => "Swing at nearby enemies for <style=cIsDamage>" + d(damage) + " damage</style>. Every third hit knocks up for an additional <style=cIsDamage>" + d(burstDamage) + " damage</style> in a large radius.";

		public override void Init()
		{
			damage = ConfigOption(1.7f, "Damage", "Decimal. Vanilla is 3.2");
			burstDamage = ConfigOption(2.3f, "Third Hit Damage", "Decimal. Vanilla is 0");
			burstAoE = ConfigOption(13f, "Third Hit AoE", "Vanilla is 0");
			fireRate = ConfigOption(2.5f, "Fire Rate", "Vanilla is 1.66666667");
			barrierGain = ConfigOption(0.033f, "Barrier Gain per Hit", "Decimal. Vanilla is 0.05");
			base.Init();
		}

		public override void Hooks()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			BasicMeleeAttack.OnEnter += new hook_OnEnter(BasicMeleeAttack_OnEnter);
			BasicMeleeAttack.OnMeleeHitAuthority += new hook_OnMeleeHitAuthority(BasicMeleeAttack_OnMeleeHitAuthority);
			LoaderMeleeAttack.OnMeleeHitAuthority += new hook_OnMeleeHitAuthority(LoaderMeleeAttack_OnMeleeHitAuthority);
		}

		private void LoaderMeleeAttack_OnMeleeHitAuthority(orig_OnMeleeHitAuthority orig, LoaderMeleeAttack self)
		{
			LoaderMeleeAttack.barrierPercentagePerHit = barrierGain;
			orig.Invoke(self);
		}

		private void BasicMeleeAttack_OnMeleeHitAuthority(orig_OnMeleeHitAuthority orig, BasicMeleeAttack self)
		{
			if (self is LoaderMeleeAttack)
			{
				((Component)((EntityState)self).characterBody).gameObject.GetComponent<KnuckleboomButBased>().HitCount++;
			}
			orig.Invoke(self);
		}

		private void BasicMeleeAttack_OnEnter(orig_OnEnter orig, BasicMeleeAttack self)
		{
			if (self is LoaderMeleeAttack)
			{
				self.baseDuration = 1f / fireRate;
				self.damageCoefficient = damage;
				self.pushAwayForce = 50f;
				if ((Object)(object)((Component)((EntityState)self).characterBody).gameObject.GetComponent<KnuckleboomButBased>() == (Object)null)
				{
					((Component)((EntityState)self).characterBody).gameObject.AddComponent<KnuckleboomButBased>();
				}
			}
			orig.Invoke(self);
		}
	}
	public class KnuckleboomButBased : MonoBehaviour
	{
		public int HitCount;

		public CharacterBody body;

		public void Start()
		{
			body = ((Component)this).GetComponent<CharacterBody>();
		}

		public void FixedUpdate()
		{
			//IL_001a: 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)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if (HitCount >= 3)
			{
				EffectManager.SpawnEffect(GroundSlam.blastEffectPrefab, new EffectData
				{
					origin = body.footPosition,
					scale = Knuckleboom.burstAoE
				}, true);
				if (Util.HasEffectiveAuthority(((Component)this).gameObject))
				{
					new BlastAttack
					{
						attacker = ((Component)body).gameObject,
						baseDamage = body.damage * Knuckleboom.burstDamage,
						baseForce = 50f,
						bonusForce = new Vector3(0f, 1500f, 0f),
						crit = body.RollCrit(),
						damageType = (DamageType)0,
						procCoefficient = 1f,
						radius = Knuckleboom.burstAoE,
						position = body.footPosition,
						attackerFiltering = (AttackerFiltering)2,
						teamIndex = body.teamComponent.teamIndex,
						falloffModel = (FalloffModel)0,
						impactEffect = EffectCatalog.FindEffectIndexFromPrefab(GroundSlam.blastImpactEffectPrefab)
					}.Fire();
				}
				HitCount = 0;
			}
		}
	}
	public class M551Pylon : TweakBase
	{
		public static float damage;

		public static float cooldown;

		public static float aoe;

		public static float fireRate;

		public static float procCoefficient;

		public static int bounces;

		public static float lifetime;

		public override string Name => ": Special : M551 Pylon";

		public override string SkillToken => "special";

		public override string DescText => "Throw a floating pylon that repeatedly <style=cIsDamage>zaps</style> up to <style=cIsDamage>3</style> nearby enemies for <style=cIsDamage>" + d(damage) + " damage</style>. Can be <style=cIsUtility>grappled</style>.";

		public override void Init()
		{
			damage = ConfigOption(0.5f, "Damage", "Decimal. Vanilla is 1");
			aoe = ConfigOption(35f, "Area of Effect", "Vanilla is 25");
			cooldown = ConfigOption(20f, "Cooldown", "Vanilla is 20");
			fireRate = ConfigOption(3f, "Fire Rate", "Vanilla is 1");
			procCoefficient = ConfigOption(0.4f, "Proc Coefficient", "Vanilla is 0.5");
			bounces = ConfigOption(1, "Bounce Count", "Vanilla is 0");
			lifetime = ConfigOption(6f, "Lifetime", "Vanilla is 15");
			base.Init();
		}

		public override void Hooks()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			Changes();
			ThrowPylon.OnEnter += new hook_OnEnter(ThrowPylon_OnEnter);
		}

		private void ThrowPylon_OnEnter(orig_OnEnter orig, ThrowPylon self)
		{
			ThrowPylon.damageCoefficient = damage;
			orig.Invoke(self);
		}

		private void Changes()
		{
			//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)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			SkillDef val = Addressables.LoadAssetAsync<SkillDef>((object)"RoR2/Base/Loader/ThrowPylon.asset").WaitForCompletion();
			val.baseRechargeInterval = cooldown;
			GameObject val2 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Loader/LoaderPylon.prefab").WaitForCompletion();
			ProjectileProximityBeamController component = val2.GetComponent<ProjectileProximityBeamController>();
			component.attackInterval = 1f / fireRate;
			component.attackRange = aoe;
			component.procCoefficient = procCoefficient;
			component.bounces = bounces;
			ProjectileSimple component2 = val2.GetComponent<ProjectileSimple>();
			component2.lifetime = lifetime;
		}
	}
	public class SpikedFist : TweakBase
	{
		public static float massLimit;

		public static float cooldown;

		public static float range;

		public override string Name => ": Secondary :: Spiked Fist";

		public override string SkillToken => "yankhook";

		public override string DescText => "<style=cIsDamage>Stunning</style>. Fire your gauntlet forward, dealing <style=cIsDamage>320% damage</style>. <style=cIsUtility>Pulls</style> you to heavy targets. Light targets are <style=cIsUtility>pulled to YOU</style> instead.";

		public override void Init()
		{
			massLimit = ConfigOption(500f, "Mass Limit", "Vanilla is 250");
			cooldown = ConfigOption(5f, "Cooldown", "Vanilla is 5");
			range = ConfigOption(80f, "Max Range", "Vanilla is 80");
			base.Init();
		}

		public override void Hooks()
		{
			Changes();
		}

		private void Changes()
		{
			//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)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Loader/LoaderYankHook.prefab").WaitForCompletion();
			ProjectileGrappleController component = val.GetComponent<ProjectileGrappleController>();
			component.yankMassLimit = massLimit;
			component.maxTravelDistance = range;
			SkillDef val2 = Addressables.LoadAssetAsync<SkillDef>((object)"RoR2/Base/Loader/FireYankHook.asset").WaitForCompletion();
			val2.baseRechargeInterval = cooldown;
		}
	}
	public class ThunderGauntlet : TweakBase
	{
		public static float damage;

		public static float chargeRate;

		public static float speedCoeff;

		public static float cooldown;

		public static bool formula;

		public override string Name => ": Utility :: Thunder Gauntlet";

		public override string SkillToken => "utility_alt1";

		public override string DescText => "<style=cIsUtility>Heavy</style>. Charge up a <style=cIsUtility>single-target</style> punch for <style=cIsDamage>" + d(damage) + " damage</style> that <style=cIsDamage>shocks</style> enemies in a cone for <style=cIsDamage>900% damage</style>.";

		public override void Init()
		{
			damage = ConfigOption(14f, "Damage", "Decimal. Vanilla is ???");
			chargeRate = ConfigOption(0.4f, "Charge Duration", "Vanilla is 0.4");
			speedCoeff = ConfigOption(0.17f, "Speed Coefficient", "Decimal. Vanilla is 0.3");
			cooldown = ConfigOption(5f, "Cooldown", "Vanilla is 5");
			formula = ConfigOption(value: true, "Damage Formula", "Damage + SpeedCoeff * (Current velocity - 90)");
			base.Init();
		}

		public override void Hooks()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			BaseChargeFist.OnEnter += new hook_OnEnter(BaseChargeFist_OnEnter);
			BaseSwingChargedFist.OnEnter += new hook_OnEnter(BaseSwingChargedFist_OnEnter);
			Changes();
		}

		private void BaseSwingChargedFist_OnEnter(orig_OnEnter orig, BaseSwingChargedFist self)
		{
			if (self is SwingZapFist)
			{
				BaseSwingChargedFist.velocityDamageCoefficient = speedCoeff;
				((BasicMeleeAttack)self).damageCoefficient = damage;
				orig.Invoke(self);
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private void BaseChargeFist_OnEnter(orig_OnEnter orig, BaseChargeFist self)
		{
			if (self is ChargeZapFist)
			{
				self.baseChargeDuration = chargeRate;
			}
			orig.Invoke(self);
		}

		private void Changes()
		{
			//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)
			SteppedSkillDef val = Addressables.LoadAssetAsync<SteppedSkillDef>((object)"RoR2/Base/Loader/ChargeZapFist.asset").WaitForCompletion();
			((SkillDef)val).baseRechargeInterval = cooldown;
		}
	}
	public class Thunderslam : TweakBase
	{
		public static float damage;

		public static float cooldown;

		public static float aoe;

		public static float yVelocityCoeff;

		public static bool formula;

		public static BuffDef fallDamageReduction;

		public override string Name => ": Special :: Thunderslam";

		public override string SkillToken => "special_alt";

		public override string DescText => "<style=cIsUtility>Very Heavy</style>. <style=cIsDamage>Stunning</style>. Slam your fists down, dealing <style=cIsDamage>" + d(damage) + "</style> damage on impact.";

		public override void Init()
		{
			damage = ConfigOption(4f, "Damage", "Decimal. Vanilla is 20");
			aoe = ConfigOption(13f, "Area of Effect", "Vanilla is 11");
			cooldown = ConfigOption(9f, "Cooldown", "Vanilla is 8");
			yVelocityCoeff = ConfigOption(0.23f, "Y Axis Speed Coefficient", "Vanilla is 0");
			formula = ConfigOption(value: true, "Damage Formula", "if Damage + Y Velocity * -1 * YVelocityCoeff >=\nDamage + YVelocityCoeff * 25,\nset the Damage to that");
			fallDamageReduction = ScriptableObject.CreateInstance<BuffDef>();
			fallDamageReduction.isHidden = true;
			fallDamageReduction.isDebuff = false;
			fallDamageReduction.canStack = false;
			fallDamageReduction.isCooldown = false;
			ContentAddition.AddBuffDef(fallDamageReduction);
			base.Init();
		}

		public override void Hooks()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			Changes();
			GroundSlam.OnEnter += new hook_OnEnter(GroundSlam_OnEnter);
			GroundSlam.FixedUpdate += new hook_FixedUpdate(GroundSlam_FixedUpdate);
			GroundSlam.OnExit += new hook_OnExit(GroundSlam_OnExit);
			GlobalEventManager.OnCharacterHitGroundServer += new hook_OnCharacterHitGroundServer(GlobalEventManager_OnCharacterHitGroundServer);
		}

		private void GlobalEventManager_OnCharacterHitGroundServer(orig_OnCharacterHitGroundServer orig, GlobalEventManager self, CharacterBody characterBody, Vector3 impactVelocity)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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 (characterBody.HasBuff(fallDamageReduction))
			{
				impactVelocity *= 0.75f;
			}
			orig.Invoke(self, characterBody, impactVelocity);
		}

		private void GroundSlam_OnExit(orig_OnExit orig, GroundSlam self)
		{
			GroundSlam.blastDamageCoefficient = damage;
			orig.Invoke(self);
			if (Object.op_Implicit((Object)(object)((EntityState)self).characterBody))
			{
				((EntityState)self).characterBody.RemoveBuff(fallDamageReduction);
			}
		}

		private void GroundSlam_FixedUpdate(orig_FixedUpdate orig, GroundSlam self)
		{
			if (((EntityState)self).isAuthority && Object.op_Implicit((Object)(object)((EntityState)self).characterMotor))
			{
				float num = damage + ((EntityState)self).characterMotor.velocity.y * -1f * yVelocityCoeff;
				if (num >= damage + yVelocityCoeff * 25f)
				{
					GroundSlam.blastDamageCoefficient = num;
				}
				orig.Invoke(self);
			}
		}

		private void GroundSlam_OnEnter(orig_OnEnter orig, GroundSlam self)
		{
			GroundSlam.blastRadius = aoe;
			if (Object.op_Implicit((Object)(object)((EntityState)self).characterBody))
			{
				((EntityState)self).characterBody.AddBuff(fallDamageReduction);
			}
			orig.Invoke(self);
		}

		private void Changes()
		{
			//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)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			SteppedSkillDef val = Addressables.LoadAssetAsync<SteppedSkillDef>((object)"RoR2/Base/Loader/GroundSlam.asset").WaitForCompletion();
			((SkillDef)val).baseRechargeInterval = cooldown;
			LanguageAPI.Add("KEYWORD_VERY_HEAVY", "<style=cKeywordName>Very Heavy</style><style=cSub>The skill deals much more damage the faster you are falling. <color=#FF7F7F>Watch out for backblast</color>.</style>");
			string[] keywordTokens = new string[1] { "KEYWORD_VERY_HEAVY" };
			SkillFamily val2 = Addressables.LoadAssetAsync<SkillFamily>((object)"RoR2/Base/Loader/LoaderBodySpecialFamily.asset").WaitForCompletion();
			val2.variants[1].skillDef.keywordTokens = keywordTokens;
		}
	}
}
namespace HIFULoaderTweaks.Misc
{
	public class FallDamageReduction : MiscBase
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_TakeDamage <>9__5_0;

			internal void <Changes>b__5_0(orig_TakeDamage orig, HealthComponent self, DamageInfo damageInfo)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				if (damageInfo != null && ((Enum)damageInfo.damageType).HasFlag((Enum)(object)(DamageType)2097152) && Object.op_Implicit((Object)(object)self.body) && ((Object)self.body).name == "LoaderBody(Clone)")
				{
					damageInfo.damage *= 1f - fallDamageReduction;
				}
				orig.Invoke(self, damageInfo);
			}
		}

		public static float fallDamageReduction;

		public override string Name => ":: Misc : Scrap Barrier";

		public override void Init()
		{
			fallDamageReduction = ConfigOption(0.6f, "Fall Damage Reduction", "Decimal. Vanilla is 1");
			base.Init();
		}

		public override void Hooks()
		{
			Changes();
		}

		public static void Changes()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//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__5_0;
			if (obj == null)
			{
				hook_TakeDamage val = delegate(orig_TakeDamage orig, HealthComponent self, DamageInfo damageInfo)
				{
					//IL_0005: Unknown result type (might be due to invalid IL or missing references)
					if (damageInfo != null && ((Enum)damageInfo.damageType).HasFlag((Enum)(object)(DamageType)2097152) && Object.op_Implicit((Object)(object)self.body) && ((Object)self.body).name == "LoaderBody(Clone)")
					{
						damageInfo.damage *= 1f - fallDamageReduction;
					}
					orig.Invoke(self, damageInfo);
				};
				<>c.<>9__5_0 = val;
				obj = (object)val;
			}
			HealthComponent.TakeDamage += (hook_TakeDamage)obj;
			LanguageAPI.Add("LOADER_PASSIVE_DESCRIPTION", "The Loader has her fall damage <style=cIsUtility>reduced by " + fallDamageReduction * 100f + "%</style>. Striking enemies with the Loader's gauntlets grants a <style=cIsHealing>temporary barrier</style>.");
			GameObject val2 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Loader/LoaderBody.prefab").WaitForCompletion();
			CharacterBody component = val2.GetComponent<CharacterBody>();
			component.bodyFlags = (BodyFlags)(component.bodyFlags & -2);
		}
	}
	public class StatChanges : MiscBase
	{
		public static float baseMaxHealth;

		public static float armor;

		public override string Name => ":: Misc :: Base Stats";

		public override void Init()
		{
			baseMaxHealth = ConfigOption(110f, "Base Max Health", "Vanilla is 160");
			armor = ConfigOption(0f, "Base Armor", "Vanilla is 20");
			base.Init();
		}

		public override void Hooks()
		{
			Changes();
		}

		private void Changes()
		{
			//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)
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Loader/LoaderBody.prefab").WaitForCompletion();
			CharacterBody component = val.GetComponent<CharacterBody>();
			component.baseMaxHealth = baseMaxHealth;
			component.levelMaxHealth = baseMaxHealth * 0.3f;
			component.baseArmor = armor;
		}
	}
}