Decompiled source of BraqsItems v1.6.0

BraqsItems.dll

Decompiled a month ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BraqsItems.Misc;
using BraqsItems.Util;
using HG;
using IL.RoR2;
using IL.RoR2.Skills;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using On.RoR2.Items;
using On.RoR2.Orbs;
using On.RoR2.Skills;
using R2API;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.ExpansionManagement;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace BraqsItems
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.Braquen.BraqsItems", "Braqs Items", "1.6.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class BraqsItemsMain : BaseUnityPlugin
	{
		public const string GUID = "com.Braquen.BraqsItems";

		public const string MODNAME = "Braqs Items";

		public const string VERSION = "1.6.0";

		public static ExpansionDef BraqsItemsExpansion;

		internal static AssetBundle assetBundle;

		public static PluginInfo PluginInfo { get; private set; }

		public static BraqsItemsMain instance { get; private set; }

		internal static string assetBundleDir => Path.Combine(Path.GetDirectoryName(PluginInfo.Location), "braqsitemsassets");

		private void Awake()
		{
			//IL_005d: 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)
			Log.Init(((BaseUnityPlugin)this).Logger);
			instance = this;
			PluginInfo = ((BaseUnityPlugin)this).Info;
			assetBundle = AssetBundle.LoadFromFile(assetBundleDir);
			ConfigManager.Init(Paths.ConfigPath);
			Stats.Init();
			CharacterEvents.Init();
			BraqsItemsExpansion = assetBundle.LoadAsset<ExpansionDef>("BraqsItemsExpansion");
			BraqsItemsExpansion.disabledIconSprite = Addressables.LoadAssetAsync<Sprite>((object)"RoR2/Base/Common/MiscIcons/texUnlockIcon.png").WaitForCompletion();
			ContentAddition.AddExpansionDef(BraqsItemsExpansion);
			BrokenItemRelationships.CreateBrokenItemProvider();
			BiggerExplosions.Init();
			AttackSpeedOnHit.Init();
			LightningOnOverkill.Init();
			LightningOnOverkillVoid.Init();
			ExplodeAgain.Init();
			RepairBrokenItems.Init();
			HealFromBleed.Init();
			SkillSaver.Init();
			HealFromBleedVoid.Init();
			ExplosionFrenzy.Init();
			HundredRendingFists.Init();
			LightningDamageBoost.Init();
		}
	}
	public class AttackSpeedOnHit
	{
		public class BraqsItems_AttackSpeedOnHitTracker : ItemBehavior
		{
			public List<CharacterBody> victims = new List<CharacterBody>();

			private void Start()
			{
			}

			public bool TryAddVictim(CharacterBody victim)
			{
				if (!victims.Contains(victim))
				{
					victims.Add(victim);
					base.body.RecalculateStats();
					return true;
				}
				return false;
			}

			public void RemoveVictim(CharacterBody victim)
			{
				if (victims.Contains(victim))
				{
					victims.Remove(victim);
					base.body.RecalculateStats();
				}
			}

			private void OnDestroy()
			{
			}
		}

		public static ItemDef itemDef;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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
			if (ConfigManager.AttackSpeedOnHit_isEnabled.Value)
			{
				Log.Info("Initializing Hundreds and Thousands Item");
				itemDef = Helpers.GetItemDef("AttackSpeedOnHit");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				Hooks();
				Log.Info("Hundreds and Thousands Initialized");
			}
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(RecalculateStatsAPI_GetStatCoefficients);
			CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(CharacterBody_OnInventoryChanged);
			GlobalEventManager.onServerDamageDealt += GlobalEventManager_onServerDamageDealt;
		}

		private static void GlobalEventManager_onServerDamageDealt(DamageReport obj)
		{
			BraqsItems_AttackSpeedOnHitTracker braqsItems_AttackSpeedOnHitTracker = default(BraqsItems_AttackSpeedOnHitTracker);
			CharacterEvents.BraqsItems_CharacterEventComponent braqsItems_CharacterEventComponent = default(CharacterEvents.BraqsItems_CharacterEventComponent);
			if (Object.op_Implicit((Object)(object)obj.attackerBody) && Object.op_Implicit((Object)(object)obj.victimMaster) && Object.op_Implicit((Object)(object)obj.victimBody.healthComponent) && obj.victimBody.healthComponent.alive && ((Component)obj.attackerBody).TryGetComponent<BraqsItems_AttackSpeedOnHitTracker>(ref braqsItems_AttackSpeedOnHitTracker) && ((Component)obj.victimMaster).TryGetComponent<CharacterEvents.BraqsItems_CharacterEventComponent>(ref braqsItems_CharacterEventComponent) && Object.op_Implicit((Object)(object)braqsItems_CharacterEventComponent.body) && braqsItems_AttackSpeedOnHitTracker.TryAddVictim(braqsItems_CharacterEventComponent.body))
			{
				braqsItems_CharacterEventComponent.OnCharacterDeath += braqsItems_AttackSpeedOnHitTracker.RemoveVictim;
			}
		}

		private static void CharacterBody_OnInventoryChanged(orig_OnInventoryChanged orig, CharacterBody self)
		{
			self.AddItemBehavior<BraqsItems_AttackSpeedOnHitTracker>(self.inventory.GetItemCount(itemDef));
			orig.Invoke(self);
		}

		public static void RecalculateStatsAPI_GetStatCoefficients(CharacterBody sender, StatHookEventArgs args)
		{
			BraqsItems_AttackSpeedOnHitTracker braqsItems_AttackSpeedOnHitTracker = default(BraqsItems_AttackSpeedOnHitTracker);
			if (((Component)sender).TryGetComponent<BraqsItems_AttackSpeedOnHitTracker>(ref braqsItems_AttackSpeedOnHitTracker))
			{
				args.attackSpeedMultAdd += (float)braqsItems_AttackSpeedOnHitTracker.victims.Count * ((float)(((ItemBehavior)braqsItems_AttackSpeedOnHitTracker).stack - 1) * ConfigManager.AttackSpeedOnHit_percentPerStack.Value + ConfigManager.AttackSpeedOnHit_percentBase.Value);
			}
		}
	}
	public class BiggerExplosions
	{
		public static ItemDef itemDef;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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
			if (ConfigManager.BiggerExplosions_isEnabled.Value)
			{
				Log.Info("Initializing Accelerant Item");
				itemDef = Helpers.GetItemDef("BiggerExplosions");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				Hooks();
				Log.Info("Acclerant Initialized");
			}
		}

		private static void Hooks()
		{
			Stats.StatsCompEvent.StatsCompRecalc = (EventHandler<Stats.StatsCompRecalcArgs>)Delegate.Combine(Stats.StatsCompEvent.StatsCompRecalc, new EventHandler<Stats.StatsCompRecalcArgs>(StatsCompEvent_StatsCompRecalc));
		}

		public static void StatsCompEvent_StatsCompRecalc(object sender, Stats.StatsCompRecalcArgs args)
		{
			if (Object.op_Implicit((Object)(object)args.Stats) && NetworkServer.active && Object.op_Implicit((Object)(object)args.Stats.inventory))
			{
				int itemCount = args.Stats.inventory.GetItemCount(itemDef);
				if (itemCount > 0)
				{
					args.Stats.blastRadiusBoostAdd *= 1f + (float)(itemCount - 1) * ConfigManager.BiggerExplosions_percentPerStack.Value + ConfigManager.BiggerExplosions_percentBase.Value;
				}
			}
		}
	}
	public class LightningOnOverkill
	{
		public static ItemDef itemDef;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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
			if (ConfigManager.LightningOnOverkill_isEnabled.Value)
			{
				Log.Info("Initializing Jumper Cables Item");
				itemDef = Helpers.GetItemDef("LightningOnOverkill");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				Hooks();
				Log.Info("Jumper Cables Initialized");
			}
		}

		private static void Hooks()
		{
			GlobalEventManager.onCharacterDeathGlobal += GlobalEventManager_onCharacterDeathGlobal;
		}

		private static void GlobalEventManager_onCharacterDeathGlobal(DamageReport obj)
		{
			//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_008d: 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_0097: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: 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)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)obj.attackerBody) || !Object.op_Implicit((Object)(object)obj.attackerBody.inventory))
			{
				return;
			}
			int itemCount = obj.attackerBody.inventory.GetItemCount(itemDef);
			if (itemCount <= 0)
			{
				return;
			}
			float num = Util.OnHitProcDamage(obj.damageDealt - obj.combinedHealthBeforeDamage, obj.attackerBody.baseDamage, (float)(itemCount - 1) * ConfigManager.LightningOnOverkill_damagePercentPerStack.Value + ConfigManager.LightningOnOverkill_damagePercentBase.Value);
			if (!(num <= 0f))
			{
				LightningOrb val = new LightningOrb
				{
					origin = obj.victimBody.corePosition,
					damageValue = num,
					isCrit = obj.damageInfo.crit,
					bouncesRemaining = ConfigManager.LightningOnOverkill_bounceBase.Value + (itemCount - 1) * ConfigManager.LightningOnOverkill_bouncePerStack.Value,
					teamIndex = obj.attackerBody.teamComponent.teamIndex,
					attacker = obj.attacker,
					procCoefficient = 0.2f,
					bouncedObjects = new List<HealthComponent> { obj.victim },
					lightningType = (LightningType)0,
					damageColorIndex = (DamageColorIndex)3,
					range = ConfigManager.LightningOnOverkill_rangeBase.Value + (float)(itemCount - 1) * ConfigManager.LightningOnOverkill_rangePerStack.Value
				};
				HurtBox val2 = val.PickNextTarget(obj.victimBody.corePosition);
				if (Object.op_Implicit((Object)(object)val2))
				{
					((Orb)val).target = val2;
					OrbManager.instance.AddOrb((Orb)(object)val);
				}
			}
		}
	}
	public class LightningOnOverkillVoid
	{
		public class BraqsItems_LightningOnOverkillVoidBehavior : ItemBehavior
		{
			private class DamageBonus
			{
				public float damage;

				public int hitsLeft;
			}

			private List<DamageBonus> damageBonuses = new List<DamageBonus>();

			private float totalDamageBonus;

			public void StoreDeathDamage(float damage)
			{
				totalDamageBonus += damage;
				damageBonuses.Add(new DamageBonus
				{
					damage = damage,
					hitsLeft = ConfigManager.LightningOnOverkillVoid_hitsBase.Value + (base.stack - 1) * ConfigManager.LightningOnOverkillVoid_hitsPerStack.Value
				});
			}

			public void FireVoidLightning(DamageInfo damageInfo, CharacterBody victimBody)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: 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_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Expected O, but got Unknown
				int count = damageBonuses.Count;
				if (count > 0 && !(totalDamageBonus <= 0f))
				{
					float damageValue = totalDamageBonus / (float)count;
					ProcChainMask procChainMask = damageInfo.procChainMask;
					ProcTypeAPI.AddModdedProc(ref procChainMask, procType);
					VoidLightningOrb val = new VoidLightningOrb
					{
						origin = damageInfo.position,
						damageValue = damageValue,
						isCrit = damageInfo.crit,
						totalStrikes = count,
						teamIndex = base.body.teamComponent.teamIndex,
						attacker = damageInfo.attacker,
						procCoefficient = 0.3f,
						procChainMask = procChainMask,
						damageColorIndex = (DamageColorIndex)9,
						secondsPerStrike = 0.1f
					};
					HurtBox mainHurtBox = victimBody.mainHurtBox;
					if (Object.op_Implicit((Object)(object)mainHurtBox))
					{
						((Orb)val).target = mainHurtBox;
						OrbManager.instance.AddOrb((Orb)(object)val);
					}
					OnBonusProcced();
				}
			}

			private void OnBonusProcced()
			{
				for (int num = damageBonuses.Count - 1; num >= 0; num--)
				{
					if (--damageBonuses[num].hitsLeft <= 0)
					{
						totalDamageBonus -= damageBonuses[num].damage;
						damageBonuses.RemoveAt(num);
					}
				}
			}
		}

		public static ItemDef itemDef;

		public static ModdedProcType procType;

		internal static void Init()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigManager.LightningOnOverkillVoid_isEnabled.Value)
			{
				Log.Info("Initializing Sunken Chains Item");
				itemDef = Helpers.GetItemDef("LightningOnOverkillVoid");
				if (ConfigManager.LightningOnOverkill_isEnabled.Value)
				{
					itemDef.AddContagiousRelationship(LightningOnOverkill.itemDef);
				}
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				procType = ProcTypeAPI.ReserveProcType();
				Hooks();
				Log.Info("Sunken Chains Initialized");
			}
		}

		private static void Hooks()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			GlobalEventManager.onCharacterDeathGlobal += GlobalEventManager_onCharacterDeathGlobal;
			GlobalEventManager.OnHitEnemy += new hook_OnHitEnemy(GlobalEventManager_OnHitEnemy);
			CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(CharacterBody_OnInventoryChanged);
		}

		private static void CharacterBody_OnInventoryChanged(orig_OnInventoryChanged orig, CharacterBody self)
		{
			self.AddItemBehavior<BraqsItems_LightningOnOverkillVoidBehavior>(self.inventory.GetItemCount(itemDef));
			orig.Invoke(self);
		}

		private static void GlobalEventManager_OnHitEnemy(orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
		{
			//IL_0016: 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)
			CharacterBody val = default(CharacterBody);
			BraqsItems_LightningOnOverkillVoidBehavior braqsItems_LightningOnOverkillVoidBehavior = default(BraqsItems_LightningOnOverkillVoidBehavior);
			CharacterBody val2 = default(CharacterBody);
			if (!damageInfo.rejected && damageInfo.procCoefficient > 0f && !ProcTypeAPI.HasModdedProc(damageInfo.procChainMask, procType) && Object.op_Implicit((Object)(object)damageInfo.attacker) && damageInfo.attacker.TryGetComponent<CharacterBody>(ref val) && ((Component)val).TryGetComponent<BraqsItems_LightningOnOverkillVoidBehavior>(ref braqsItems_LightningOnOverkillVoidBehavior) && victim.TryGetComponent<CharacterBody>(ref val2) && Object.op_Implicit((Object)(object)val2.healthComponent) && val2.healthComponent.alive && ((DamageTypeCombo)(ref damageInfo.damageType)).IsDamageSourceSkillBased)
			{
				braqsItems_LightningOnOverkillVoidBehavior.FireVoidLightning(damageInfo, val2);
			}
			orig.Invoke(self, damageInfo, victim);
		}

		private static void GlobalEventManager_onCharacterDeathGlobal(DamageReport obj)
		{
			BraqsItems_LightningOnOverkillVoidBehavior braqsItems_LightningOnOverkillVoidBehavior = default(BraqsItems_LightningOnOverkillVoidBehavior);
			if (!Object.op_Implicit((Object)(object)obj.attackerBody) || !((Component)obj.attackerBody).TryGetComponent<BraqsItems_LightningOnOverkillVoidBehavior>(ref braqsItems_LightningOnOverkillVoidBehavior))
			{
				return;
			}
			int itemCount = obj.attackerBody.inventory.GetItemCount(itemDef);
			if (itemCount > 0)
			{
				float num = ConfigManager.LightningOnOverkillVoid_damagePercentBase.Value + (float)(itemCount - 1) * ConfigManager.LightningOnOverkillVoid_damagePercentPerStack.Value;
				num *= (obj.damageDealt - obj.combinedHealthBeforeDamage) / obj.damageDealt;
				float num2 = Util.OnHitProcDamage(obj.attackerBody.damage, obj.attackerBody.baseDamage, num);
				Debug.Log((object)("Storing " + num2 + " damage from overkill."));
				if (!(num2 <= 0f))
				{
					braqsItems_LightningOnOverkillVoidBehavior.StoreDeathDamage(num2);
				}
			}
		}
	}
	public class ExplodeAgain
	{
		public static ItemDef itemDef;

		public static ModdedProcType procType;

		private static GameObject bomblettePrefab;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_003e: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigManager.ExplodeAgain_isEnabled.Value)
			{
				Log.Info("Initializing Bomblette Item");
				itemDef = Helpers.GetItemDef("ExplodeAgain");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				procType = ProcTypeAPI.ReserveProcType();
				bomblettePrefab = PrefabAPI.InstantiateClone(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Toolbot/CryoCanisterBombletsProjectile.prefab").WaitForCompletion(), "inertBomblet");
				Hooks();
				Log.Info("Bomblette Initialized");
			}
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			BlastAttack.Fire += new hook_Fire(BlastAttack_Fire);
		}

		private static Result BlastAttack_Fire(orig_Fire orig, BlastAttack self)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody val = default(CharacterBody);
			if (NetworkServer.active && Object.op_Implicit((Object)(object)self.attacker) && self.attacker.TryGetComponent<CharacterBody>(ref val) && Object.op_Implicit((Object)(object)val.inventory))
			{
				int itemCount = val.inventory.GetItemCount(itemDef);
				if (itemCount > 0 && !ProcTypeAPI.HasModdedProc(self.procChainMask, procType))
				{
					FireChildExplosions(self, val, itemCount);
				}
			}
			return orig.Invoke(self);
		}

		private static void FireChildExplosions(BlastAttack self, CharacterBody body, int items)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_0096: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			if (self.procCoefficient == 0f && !ConfigManager.ExplodeAgain_ignoreProcCoefficient.Value)
			{
				return;
			}
			Vector3 position = self.position;
			Vector3 up = Vector3.up;
			int num = (items - 1) * ConfigManager.ExplodeAgain_maxBombsPerStack.Value + ConfigManager.ExplodeAgain_maxBombsBase.Value;
			GameObject val = bomblettePrefab;
			ProjectileExplosion component = val.GetComponent<ProjectileExplosion>();
			component.blastRadius = self.radius * ConfigManager.ExplodeAgain_radiusCoefficient.Value;
			component.blastProcCoefficient = self.procCoefficient;
			float damage = Util.OnHitProcDamage(self.baseDamage, body.damage, ConfigManager.ExplodeAgain_damageCoefficient.Value);
			ProcChainMask procChainMask = self.procChainMask;
			ProcTypeAPI.AddModdedProc(ref procChainMask, procType);
			float num2 = (ConfigManager.ExplodeAgain_ignoreProcCoefficient.Value ? 1f : self.procCoefficient);
			for (int i = 0; i < num; i++)
			{
				if (Util.CheckRoll(ConfigManager.ExplodeAgain_chance.Value * num2, body.master))
				{
					float speedOverride = Random.Range(0.5f, 1f) * self.radius * 3f;
					float num3 = (float)i * MathF.PI * 2f / (float)num;
					up.x += Mathf.Sin(num3);
					up.z += Mathf.Cos(num3);
					FireProjectileInfo val2 = default(FireProjectileInfo);
					val2.projectilePrefab = val;
					val2.position = position + new Vector3(Mathf.Sin(num3), 0f, Mathf.Cos(num3));
					val2.rotation = Util.QuaternionSafeLookRotation(up);
					val2.procChainMask = procChainMask;
					val2.owner = self.attacker;
					val2.damage = damage;
					val2.crit = self.crit;
					val2.force = self.baseForce;
					val2.damageColorIndex = (DamageColorIndex)3;
					((FireProjectileInfo)(ref val2)).speedOverride = speedOverride;
					val2.useSpeedOverride = true;
					FireProjectileInfo val3 = val2;
					ProjectileManager.instance.FireProjectile(val3);
				}
			}
		}
	}
	public class HealFromBleed
	{
		public static ItemDef itemDef;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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
			if (ConfigManager.HealFromBleed_isEnabled.Value)
			{
				Log.Info("Initializing Leech Jar Item");
				itemDef = Helpers.GetItemDef("HealFromBleed");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				Hooks();
				Log.Info("Leech Jar Initialized");
			}
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			HealthComponent.TakeDamage += new hook_TakeDamage(HealthComponent_TakeDamage);
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(RecalculateStatsAPI_GetStatCoefficients);
		}

		private static void RecalculateStatsAPI_GetStatCoefficients(CharacterBody sender, StatHookEventArgs args)
		{
			if (Object.op_Implicit((Object)(object)sender) && Object.op_Implicit((Object)(object)sender.inventory) && sender.inventory.GetItemCount(itemDef) > 0)
			{
				args.bleedChanceAdd += 5f;
			}
		}

		private static float GetExtraBleedChance(Inventory inventory)
		{
			if (inventory.GetItemCount(itemDef) <= 0)
			{
				return 0f;
			}
			return 5f;
		}

		private static void HealthComponent_TakeDamage(orig_TakeDamage orig, HealthComponent self, DamageInfo damageInfo)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody val = default(CharacterBody);
			if (((!damageInfo.rejected && (int)damageInfo.dotIndex == 0) || (int)damageInfo.dotIndex == 6) && Object.op_Implicit((Object)(object)damageInfo.attacker) && damageInfo.attacker.TryGetComponent<CharacterBody>(ref val) && Object.op_Implicit((Object)(object)val.inventory))
			{
				int itemCount = val.inventory.GetItemCount(itemDef);
				if (itemCount > 0)
				{
					float healValue = ((float)(itemCount - 1) * ConfigManager.HealFromBleed_percentPerStack.Value + ConfigManager.HealFromBleed_percentBase.Value) * val.maxHealth * damageInfo.damage / val.damage;
					HealOrb val2 = new HealOrb();
					((Orb)val2).origin = ((Component)self).transform.position;
					((Orb)val2).target = val.mainHurtBox;
					val2.healValue = healValue;
					OrbManager.instance.AddOrb((Orb)(object)val2);
				}
			}
			orig.Invoke(self, damageInfo);
		}
	}
	public class RepairBrokenItems
	{
		public static ItemDef itemDef;

		public static Dictionary<ItemTier, int> tierWeights;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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
			if (ConfigManager.RepairBrokenItems_isEnabled.Value)
			{
				Log.Info("Initializing Goobo Sr. Item");
				itemDef = Helpers.GetItemDef("RepairBrokenItems");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				Hooks();
				Log.Info("Goobo Sr. Initialized");
			}
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			CharacterMaster.OnServerStageBegin += new hook_OnServerStageBegin(CharacterMaster_OnServerStageBegin);
		}

		private unsafe static void CharacterMaster_OnServerStageBegin(orig_OnServerStageBegin orig, CharacterMaster self, Stage stage)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Invalid comparison between Unknown and I4
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Invalid comparison between Unknown and I4
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Invalid comparison between Unknown and I4
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, stage);
			int itemCount = self.inventory.GetItemCount(itemDef);
			if (itemCount <= 0 || !Object.op_Implicit((Object)(object)self) || !Object.op_Implicit((Object)(object)stage))
			{
				return;
			}
			itemCount = (itemCount - 1) * ConfigManager.RepairBrokenItems_repairsPerStack.Value + ConfigManager.RepairBrokenItems_repairsBase.Value;
			ReadOnlyArray<Pair> itemPairsForRelationship = ItemCatalog.GetItemPairsForRelationship(BrokenItemRelationships.brokenItemRelationship);
			int length = itemPairsForRelationship.Length;
			float[] array = new float[length];
			float[] array2 = new float[length];
			float num = 0f;
			for (int i = 0; i < length; i++)
			{
				Pair val = Unsafe.Read<Pair>((void*)itemPairsForRelationship[i]);
				int itemCount2 = self.inventory.GetItemCount(val.itemDef2);
				if ((int)val.itemDef1.tier == 0 || (int)val.itemDef1.tier == 6)
				{
					array2[i] = ConfigManager.RepairBrokenItems_whiteChance.Value;
				}
				else if ((int)val.itemDef1.tier == 2 || (int)val.itemDef1.tier == 8)
				{
					array2[i] = ConfigManager.RepairBrokenItems_redChance.Value;
				}
				else
				{
					array2[i] = ConfigManager.RepairBrokenItems_defaultChance.Value;
				}
				array[i] = itemCount2;
				num += (float)itemCount2;
			}
			if (num <= 0f)
			{
				return;
			}
			int[] array3 = new int[length];
			for (int j = 0; j < itemCount; j++)
			{
				if (!(num > 0f))
				{
					break;
				}
				float num2 = 0f;
				float num3 = Random.Range(0f, num);
				for (int k = 0; k < length; k++)
				{
					num2 += array[k];
					if (num2 >= num3)
					{
						if (Util.CheckRoll(array2[k], self))
						{
							array3[k]++;
						}
						array[k] -= 1f;
						num -= 1f;
						break;
					}
				}
			}
			for (int l = 0; l < array3.Length; l++)
			{
				tryRepairItems(self, Unsafe.Read<Pair>((void*)itemPairsForRelationship[l]), array3[l]);
			}
		}

		public static void tryRepairItems(CharacterMaster master, Pair pair, int count)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//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_005d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)master == (Object)null) && count > 0)
			{
				count = Math.Min(count, master.inventory.GetItemCount(pair.itemDef2));
				master.inventory.RemoveItem(pair.itemDef2, count);
				master.inventory.GiveItem(pair.itemDef1, count);
				CharacterMasterNotificationQueue.SendTransformNotification(master, pair.itemDef2.itemIndex, pair.itemDef1.itemIndex, (TransformationType)5);
			}
		}
	}
	public static class SkillSaver
	{
		public static ItemDef itemDef;

		public static GameObject pillEffect;

		public static GameObject restockEffect;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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
			if (ConfigManager.SkillSaver_isEnabled.Value)
			{
				Log.Info("Initializing Rhino Pill Item");
				itemDef = Helpers.GetItemDef("SkillSaver");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				GenerateEffect();
				Hooks();
				Log.Info("Rhino Pill Initialized");
			}
		}

		private static void GenerateEffect()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				pillEffect = PrefabAPI.InstantiateClone(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/VFX/CoinImpact.prefab").WaitForCompletion(), "BluePills");
				MainModule main = ((Component)pillEffect.transform.Find("CoinParticle")).gameObject.GetComponent<ParticleSystem>().main;
				((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(0.3f);
				((Renderer)((Component)pillEffect.transform.Find("CoinParticle")).gameObject.GetComponent<ParticleSystemRenderer>()).material.SetColor("_Color", new Color(0f, 0.5f, 1f));
				ContentAddition.AddEffect(pillEffect);
			}
			catch (Exception ex)
			{
				Log.Warning("SkillSaver:GenerateEffect() ; Could not edit coin impact.\n" + ex);
			}
			try
			{
				restockEffect = PrefabAPI.InstantiateClone(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/VFX/EquipmentRestockEffect.prefab").WaitForCompletion(), "SkillStock");
				((Component)restockEffect.transform.Find("Light")).gameObject.GetComponent<Light>().color = new Color(0.1f, 0.6f, 1f);
				GameObject gameObject = ((Component)restockEffect.transform.Find("MotionEmitter")).gameObject;
				((Renderer)((Component)gameObject.transform.Find("SquaresEmitter")).gameObject.GetComponent<ParticleSystemRenderer>()).material.SetColor("_TintColor", new Color(0f, 0.5f, 1f));
				((Renderer)((Component)gameObject.transform.Find("FlashEmitter")).gameObject.GetComponent<ParticleSystemRenderer>()).material.SetColor("_TintColor", new Color(0.1f, 0.6f, 1f));
				ContentAddition.AddEffect(restockEffect);
			}
			catch (Exception ex2)
			{
				Log.Warning("SkillSaver:GenerateEffect() ; Could not edit restock effect.\n" + ex2);
			}
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			EquipmentSlot.OnEquipmentExecuted += new Manipulator(EquipmentSlot_OnEquipmentExecuted);
			SkillDef.OnExecute += new Manipulator(SkillDef_OnExecute);
			MercDashSkillDef.OnExecute += new hook_OnExecute(MercDashSkillDef_OnExecute);
		}

		private static void GenericSkill_DeductStock(orig_DeductStock orig, GenericSkill self, int count)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)self.characterBody) && Object.op_Implicit((Object)(object)self.characterBody.inventory) && Object.op_Implicit((Object)(object)self.characterBody.master))
			{
				int itemCount = self.characterBody.inventory.GetItemCount(itemDef);
				if (itemCount > 0)
				{
					int num = count;
					float num2 = (float)itemCount * ConfigManager.SkillSaver_chance.Value / ((float)itemCount * ConfigManager.SkillSaver_chance.Value + 100f) * 100f;
					for (int i = 0; i < count; i++)
					{
						count -= (Util.CheckRoll(num2, self.characterBody.master) ? 1 : 0);
					}
					if (num != count)
					{
						Util.PlaySound("Play_UI_equipment_activate", ((Component)self.characterBody).gameObject);
						EffectData val = new EffectData
						{
							scale = 1f,
							origin = self.characterBody.corePosition
						};
						EffectManager.SpawnEffect(pillEffect, val, true);
						val.SetNetworkedObjectReference(((Component)self.characterBody).gameObject);
						EffectManager.SpawnEffect(restockEffect, val, true);
					}
				}
			}
			orig.Invoke(self, count);
		}

		private static void MercDashSkillDef_OnExecute(orig_OnExecute orig, MercDashSkillDef self, GenericSkill skillSlot)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, skillSlot);
			CharacterBody characterBody = skillSlot.characterBody;
			if (Object.op_Implicit((Object)(object)characterBody))
			{
				int itemCount = characterBody.inventory.GetItemCount(itemDef);
				if (itemCount > 0 && Util.CheckRoll((float)itemCount * ConfigManager.SkillSaver_chance.Value / ((float)itemCount * ConfigManager.SkillSaver_chance.Value + 100f) * 100f, characterBody.master))
				{
					Util.PlaySound("Play_UI_equipment_activate", ((Component)characterBody).gameObject);
					EffectData val = new EffectData
					{
						scale = 1f,
						origin = characterBody.corePosition
					};
					EffectManager.SpawnEffect(pillEffect, val, true);
					val.SetNetworkedObjectReference(((Component)characterBody).gameObject);
					EffectManager.SpawnEffect(restockEffect, val, true);
					InstanceData val2 = (InstanceData)skillSlot.skillInstanceData;
					skillSlot.stock += 1;
					val2.waitingForHit = false;
					val2.hasExtraStock = true;
				}
			}
		}

		private static void EquipmentSlot_OnEquipmentExecuted(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			try
			{
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[5]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<EquipmentSlot>(x, "inventory"),
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<EquipmentSlot>(x, "get_activeEquipmentSlot"),
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 1)
				});
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<int, EquipmentSlot, int>>((Func<int, EquipmentSlot, int>)((int i, EquipmentSlot c) => TryPreventStockConsumption(i, c.characterBody)));
			}
			catch (Exception e)
			{
				Helpers.ErrorHookFailed("Add equip save chance", e);
			}
		}

		private static void SkillDef_OnExecute(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			try
			{
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[5]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
					(Instruction x) => ILPatternMatchingExt.MatchDup(x),
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<GenericSkill>(x, "get_stock"),
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<SkillDef>(x, "stockToConsume")
				});
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Func<int, GenericSkill, int>>((Func<int, GenericSkill, int>)((int i, GenericSkill c) => (c.skillDef is MercDashSkillDef || (!(c.baseRechargeInterval > 0f) && c.rechargeStock != 0)) ? i : TryPreventStockConsumption(i, c.characterBody)));
			}
			catch (Exception e)
			{
				Helpers.ErrorHookFailed("Add skill save chance", e);
			}
		}

		private static int TryPreventStockConsumption(int stocksToConsume, CharacterBody characterBody)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			if (stocksToConsume > 0 && Object.op_Implicit((Object)(object)characterBody.master) && Object.op_Implicit((Object)(object)characterBody.inventory))
			{
				int itemCount = characterBody.inventory.GetItemCount(itemDef);
				if (itemCount > 0 && Util.CheckRoll((float)itemCount * ConfigManager.SkillSaver_chance.Value / ((float)itemCount * ConfigManager.SkillSaver_chance.Value + 100f) * 100f, characterBody.master))
				{
					Util.PlaySound("Play_UI_equipment_activate", ((Component)characterBody).gameObject);
					EffectData val = new EffectData
					{
						scale = 1f,
						origin = characterBody.corePosition
					};
					EffectManager.SpawnEffect(pillEffect, val, true);
					val.SetNetworkedObjectReference(((Component)characterBody).gameObject);
					EffectManager.SpawnEffect(restockEffect, val, true);
					return 0;
				}
			}
			return stocksToConsume;
		}
	}
	public class HealFromBleedVoid
	{
		public static ItemDef itemDef;

		private static GameObject healBurstPrefab;

		internal static void Init()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			Log.Info("Initializing Royal Tick Item");
			itemDef = Helpers.GetItemDef("HealFromBleedVoid");
			if (ConfigManager.HealFromBleed_isEnabled.Value)
			{
				itemDef.AddContagiousRelationship(HealFromBleed.itemDef);
			}
			ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
			ItemAPI.Add(new CustomItem(itemDef, val));
			healBurstPrefab = generateEffects();
			ContentAddition.AddEffect(healBurstPrefab);
			Hooks();
			Log.Info("Royal Tick Initialized");
		}

		private static GameObject generateEffects()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			Color val = default(Color);
			((Color)(ref val))..ctor(87.1f, 67.8f, 98f);
			Gradient val2 = new Gradient();
			val2.mode = (GradientMode)0;
			val2.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
			{
				new GradientAlphaKey
				{
					alpha = 181f,
					time = 0f
				},
				new GradientAlphaKey
				{
					alpha = 0f,
					time = 1f
				}
			};
			val2.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey
				{
					color = val,
					time = 0f
				},
				new GradientColorKey
				{
					color = new Color(0f, 0f, 0f),
					time = 1f
				}
			};
			GameObject obj = PrefabAPI.InstantiateClone(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/EliteEarth/AffixEarthHealExplosion.prefab").WaitForCompletion(), "VoidHealPulse");
			Texture val3 = Addressables.LoadAssetAsync<Texture>((object)"RoR2/Base/Common/ColorRamps/texRampNullifierSmooth.png").WaitForCompletion();
			GameObject obj2 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/MushroomVoid/MushroomVoidEffect.prefab").WaitForCompletion();
			ParticleSystem component = ((Component)obj2.transform.Find("Visual/Stars")).gameObject.GetComponent<ParticleSystem>();
			ParticleSystemRenderer component2 = ((Component)obj2.transform.Find("Visual/Stars")).gameObject.GetComponent<ParticleSystemRenderer>();
			Object.Destroy((Object)(object)((Component)obj.transform.Find("Flash, White")).gameObject);
			Object.Destroy((Object)(object)((Component)obj.transform.Find("Flash, Blue")).gameObject);
			((Renderer)((Component)obj.transform.Find("Chunks")).gameObject.GetComponent<ParticleSystemRenderer>()).material.SetTexture("_RemapTex", val3);
			Light component3 = ((Component)obj.transform.Find("Point Light")).gameObject.GetComponent<Light>();
			component3.color = val;
			component3.range = 1f;
			((Renderer)((Component)obj.transform.Find("Nova Sphere")).gameObject.GetComponent<ParticleSystemRenderer>()).material.SetTexture("_RemapTex", val3);
			ParticleSystem component4 = ((Component)obj.transform.Find("LightShafts")).gameObject.GetComponent<ParticleSystem>();
			MainModule main = component4.main;
			((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(val);
			ColorOverLifetimeModule colorOverLifetime = component4.colorOverLifetime;
			((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(val2);
			((Renderer)((Component)obj.transform.Find("Rapid Small FLash, Blue")).gameObject.GetComponent<ParticleSystemRenderer>()).materials = ((Renderer)component2).materials;
			ParticleSystem component5 = ((Component)obj.transform.Find("Rapid Small FLash, Blue")).gameObject.GetComponent<ParticleSystem>();
			MainModule main2 = component5.main;
			((MainModule)(ref main2)).maxParticles = 100;
			((MainModule)(ref main2)).startLifetime = MinMaxCurve.op_Implicit(0.5f);
			RotationOverLifetimeModule rotationOverLifetime = component5.rotationOverLifetime;
			((RotationOverLifetimeModule)(ref rotationOverLifetime)).enabled = true;
			RotationOverLifetimeModule rotationOverLifetime2 = component.rotationOverLifetime;
			((RotationOverLifetimeModule)(ref rotationOverLifetime)).x = ((RotationOverLifetimeModule)(ref rotationOverLifetime2)).x;
			rotationOverLifetime2 = component.rotationOverLifetime;
			((RotationOverLifetimeModule)(ref rotationOverLifetime)).y = ((RotationOverLifetimeModule)(ref rotationOverLifetime2)).y;
			rotationOverLifetime2 = component.rotationOverLifetime;
			((RotationOverLifetimeModule)(ref rotationOverLifetime)).z = ((RotationOverLifetimeModule)(ref rotationOverLifetime2)).z;
			rotationOverLifetime2 = component.rotationOverLifetime;
			((RotationOverLifetimeModule)(ref rotationOverLifetime)).xMultiplier = ((RotationOverLifetimeModule)(ref rotationOverLifetime2)).xMultiplier;
			rotationOverLifetime2 = component.rotationOverLifetime;
			((RotationOverLifetimeModule)(ref rotationOverLifetime)).yMultiplier = ((RotationOverLifetimeModule)(ref rotationOverLifetime2)).yMultiplier;
			rotationOverLifetime2 = component.rotationOverLifetime;
			((RotationOverLifetimeModule)(ref rotationOverLifetime)).zMultiplier = ((RotationOverLifetimeModule)(ref rotationOverLifetime2)).zMultiplier;
			ColorOverLifetimeModule colorOverLifetime2 = component5.colorOverLifetime;
			((ColorOverLifetimeModule)(ref colorOverLifetime2)).enabled = true;
			ColorOverLifetimeModule colorOverLifetime3 = component.colorOverLifetime;
			((ColorOverLifetimeModule)(ref colorOverLifetime2)).color = ((ColorOverLifetimeModule)(ref colorOverLifetime3)).color;
			SizeOverLifetimeModule sizeOverLifetime = component5.sizeOverLifetime;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).enabled = true;
			SizeOverLifetimeModule sizeOverLifetime2 = component.sizeOverLifetime;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).size = ((SizeOverLifetimeModule)(ref sizeOverLifetime2)).size;
			MainModule main3 = component.main;
			((MainModule)(ref main2)).startColor = ((MainModule)(ref main3)).startColor;
			EffectComponent val4 = default(EffectComponent);
			obj.TryGetComponent<EffectComponent>(ref val4);
			val4.applyScale = true;
			return obj;
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			GlobalEventManager.ProcessHitEnemy += new Manipulator(GlobalEventManager_ProcessHitEnemy);
			HealthComponent.TakeDamage += new hook_TakeDamage(HealthComponent_TakeDamage);
		}

		private static void GlobalEventManager_ProcessHitEnemy(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			try
			{
				val.GotoNext((MoveType)0, new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 29),
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 0)
				});
				val.Remove();
				val.Remove();
				val.Remove();
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[7]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<DamageInfo>(x, "procCoefficient"),
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 29),
					(Instruction x) => ILPatternMatchingExt.MatchConvR4(x),
					(Instruction x) => ILPatternMatchingExt.MatchMul(x),
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 10f),
					(Instruction x) => ILPatternMatchingExt.MatchMul(x)
				});
				val.Emit(OpCodes.Ldloc, 7);
				val.EmitDelegate<Func<Inventory, float>>((Func<Inventory, float>)GetExtraCollapseChance);
				val.Emit(OpCodes.Add);
			}
			catch (Exception e)
			{
				Helpers.ErrorHookFailed("Add base collapse chance", e);
			}
		}

		private static float GetExtraCollapseChance(Inventory inventory)
		{
			if (inventory.GetItemCount(itemDef) <= 0)
			{
				return 0f;
			}
			return 5f;
		}

		private static void HealthComponent_TakeDamage(orig_TakeDamage orig, HealthComponent self, DamageInfo damageInfo)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			CharacterBody val = default(CharacterBody);
			if (!damageInfo.rejected && (int)damageInfo.dotIndex == 8 && Object.op_Implicit((Object)(object)damageInfo.attacker) && damageInfo.attacker.TryGetComponent<CharacterBody>(ref val) && Object.op_Implicit((Object)(object)val.inventory))
			{
				int itemCount = val.inventory.GetItemCount(itemDef);
				if (itemCount > 0 && Object.op_Implicit((Object)(object)val.healthComponent))
				{
					_ = val.healthComponent;
					FireHealBurst(((float)(itemCount - 1) * ConfigManager.HealFromBleedVoid_percentPerStack.Value + ConfigManager.HealFromBleedVoid_percentBase.Value) * damageInfo.damage / val.damage, itemCount, val);
				}
			}
			orig.Invoke(self, damageInfo);
		}

		private static void FireHealBurst(float fractionalHeal, int stack, CharacterBody body)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_004f: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			if (stack <= 0)
			{
				Log.Warning("FireHealBurst called with no stacks");
				return;
			}
			float num = ConfigManager.HealFromBleedVoid_radiusBase.Value + ConfigManager.HealFromBleedVoid_radiusPerStack.Value * (float)(stack - 1);
			EffectData val = new EffectData
			{
				scale = num,
				origin = body.corePosition
			};
			EffectManager.SpawnEffect(healBurstPrefab, val, true);
			SphereSearch val2 = new SphereSearch
			{
				mask = ((LayerIndex)(ref LayerIndex.entityPrecise)).mask,
				origin = body.corePosition,
				queryTriggerInteraction = (QueryTriggerInteraction)2,
				radius = num
			};
			TeamMask val3 = default(TeamMask);
			((TeamMask)(ref val3)).AddTeam(body.teamComponent.teamIndex);
			List<HurtBox> list = new List<HurtBox>();
			val2.RefreshCandidates().FilterCandidatesByHurtBoxTeam(val3).FilterCandidatesByDistinctHurtBoxEntities()
				.GetHurtBoxes(list);
			int i = 0;
			for (int count = list.Count; i < count; i++)
			{
				HealthComponent healthComponent = list[i].healthComponent;
				healthComponent.HealFraction(fractionalHeal, default(ProcChainMask));
				Util.PlaySound("Play_item_proc_TPhealingNova_hitPlayer", ((Component)healthComponent).gameObject);
			}
		}
	}
	public class ConfusionOnHit
	{
		public class BraqsItems_BetrayedBehavior : MonoBehaviour
		{
			public CharacterBody body;

			private HealthComponent healthComponent;

			private List<HealthComponent> previousTargetList = new List<HealthComponent>();

			private float coinFireTimer;

			private float resetListTimer;

			private const float resetListInterval = 1f;

			private const float coinFireInterval = 0.5f;

			private bool hasBuff
			{
				get
				{
					if (body.GetBuffCount(buffDef) > 0)
					{
						return Object.op_Implicit((Object)(object)healthComponent);
					}
					return false;
				}
			}

			private void Start()
			{
				if (Object.op_Implicit((Object)(object)body.healthComponent))
				{
					healthComponent = body.healthComponent;
					previousTargetList.Add(healthComponent);
				}
			}

			private void OnDestroy()
			{
			}

			private void FixedUpdate()
			{
				if (!hasBuff)
				{
					Object.Destroy((Object)(object)this);
				}
				coinFireTimer += Time.fixedDeltaTime;
				resetListTimer += Time.fixedDeltaTime;
				if (coinFireTimer >= 0.5f)
				{
					coinFireTimer = 0f;
					FireDistractionOrb();
					previousTargetList.Clear();
					if (Object.op_Implicit((Object)(object)healthComponent))
					{
						previousTargetList.Add(healthComponent);
					}
				}
			}

			private void FireDistractionOrb()
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				DistractionOrb distractionOrb = new DistractionOrb
				{
					origin = body.transform.position,
					attacker = ((Component)body).gameObject,
					victimTeam = body.teamComponent.teamIndex,
					bouncedObjects = previousTargetList
				};
				HurtBox val = distractionOrb.PickTarget();
				if (Object.op_Implicit((Object)(object)val))
				{
					((Orb)distractionOrb).target = val;
					previousTargetList.Add(val.healthComponent);
					OrbManager.instance.AddOrb((Orb)(object)distractionOrb);
				}
			}
		}

		private class DistractionOrb : GenericDamageOrb
		{
			public float overrideDuration = 0.6f;

			public float range = 50f;

			private BullseyeSearch search;

			public List<HealthComponent> bouncedObjects;

			public TeamIndex victimTeam;

			public override void Begin()
			{
				//IL_0017: 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_0028: 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)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				((Orb)this).duration = overrideDuration;
				base.scale = 1f;
				EffectData val = new EffectData
				{
					scale = base.scale,
					origin = ((Orb)this).origin,
					genericFloat = ((Orb)this).duration
				};
				val.SetHurtBoxReference(((Orb)this).target);
				EffectManager.SpawnEffect(((GenericDamageOrb)this).GetOrbEffect(), val, true);
				base.isCrit = false;
				base.procCoefficient = 0f;
				base.damageValue = 0f;
				base.damageType = DamageTypeCombo.op_Implicit((DamageType)0);
			}

			public override GameObject GetOrbEffect()
			{
				return distractionOrbEffect;
			}

			public HurtBox PickTarget()
			{
				//IL_0001: 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_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_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: 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_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Expected O, but got Unknown
				_ = ((Orb)this).origin;
				if (search == null)
				{
					search = new BullseyeSearch();
				}
				search.searchOrigin = ((Orb)this).origin;
				search.searchDirection = Vector3.zero;
				search.teamMaskFilter = TeamMask.none;
				((TeamMask)(ref search.teamMaskFilter)).AddTeam(victimTeam);
				search.filterByLoS = false;
				search.sortMode = (SortMode)1;
				search.maxDistanceFilter = range;
				search.RefreshCandidates();
				HurtBox val = (from v in search.GetResults()
					where !bouncedObjects.Contains(v.healthComponent)
					select v).FirstOrDefault();
				if (Object.op_Implicit((Object)(object)val))
				{
					bouncedObjects.Add(val.healthComponent);
				}
				else
				{
					Debug.Log((object)"DistractionOrb:PickTarget() | No Target Found");
				}
				return val;
			}

			public override void OnArrival()
			{
				((GenericDamageOrb)this).OnArrival();
			}

			public static void FireDistractionOrbs(GameObject victim, int count, float buffDuration = 0f)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Expected O, but got I4
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068->IL0068: Incompatible stack types: O vs I4
				//IL_005c->IL0068: Incompatible stack types: I4 vs O
				//IL_005c->IL0068: Incompatible stack types: O vs I4
				List<HealthComponent> list = new List<HealthComponent>();
				HealthComponent item = default(HealthComponent);
				if (victim.TryGetComponent<HealthComponent>(ref item))
				{
					list.Add(item);
				}
				BullseyeSearch val = new BullseyeSearch();
				CharacterBody val2 = default(CharacterBody);
				for (int i = 0; i < count; i++)
				{
					DistractionOrb distractionOrb = new DistractionOrb();
					distractionOrb.search = val;
					((Orb)distractionOrb).origin = victim.transform.position;
					((GenericDamageOrb)distractionOrb).attacker = victim;
					object obj = distractionOrb;
					int num;
					if (victim.TryGetComponent<CharacterBody>(ref val2))
					{
						obj = val2.teamComponent.teamIndex;
						num = (int)obj;
					}
					else
					{
						num = -1;
						obj = num;
						num = (int)obj;
					}
					((DistractionOrb)num).victimTeam = (TeamIndex)obj;
					distractionOrb.bouncedObjects = list;
					HurtBox val3 = distractionOrb.PickTarget();
					if (Object.op_Implicit((Object)(object)val3))
					{
						((Orb)distractionOrb).target = val3;
						list.Add(val3.healthComponent);
						OrbManager.instance.AddOrb((Orb)(object)distractionOrb);
						continue;
					}
					break;
				}
			}
		}

		public static ItemDef itemDef;

		public static BuffDef buffDef;

		public static DotIndex dotIndex;

		private static GameObject distractionOrbEffect;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigManager.ConfusionOnHit_isEnabled.Value)
			{
				Log.Info("Initializing Pieces of Silver Item");
				itemDef = Helpers.GetItemDef("ConfusionOnHit");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				buffDef = ScriptableObject.CreateInstance<BuffDef>();
				((Object)buffDef).name = "Betrayed";
				buffDef.canStack = false;
				buffDef.isHidden = false;
				buffDef.isDebuff = true;
				buffDef.buffColor = Color.white;
				buffDef.isCooldown = false;
				buffDef.iconSprite = BraqsItemsMain.assetBundle.LoadAsset<Sprite>("texBuffBetrayedIcon");
				ContentAddition.AddBuffDef(buffDef);
				DotAPI.RegisterDotDef(new DotDef
				{
					interval = 0.2f,
					damageCoefficient = 0f,
					damageColorIndex = (DamageColorIndex)3,
					associatedBuff = buffDef
				}, (CustomDotBehaviour)null, (CustomDotVisual)null);
				distractionOrbEffect = GenerateEffect();
				ContentAddition.AddEffect(distractionOrbEffect);
				Hooks();
				Log.Info("Pieces of Silver Initialized");
			}
		}

		private static GameObject GenerateEffect()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_00aa: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_00ea: 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_0106: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = PrefabAPI.InstantiateClone(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/GoldOrbEffect.prefab").WaitForCompletion(), "DistractionCoins");
			Texture val2 = Addressables.LoadAssetAsync<Texture>((object)"RoR2/Base/Common/ColorRamps/texRampBrotherPillar.png").WaitForCompletion();
			try
			{
				((Renderer)((Component)val.transform.Find("TrailParent/Trail")).gameObject.GetComponent<TrailRenderer>()).material.SetTexture("_RemapTex", val2);
			}
			catch (Exception ex)
			{
				Log.Warning("ConfusionOnHit:GenerateEffect() ; Could not edit coin orb trail.\n" + ex);
			}
			try
			{
				ColorOverLifetimeModule colorOverLifetime = ((Component)val.transform.Find("VFX/Core")).gameObject.GetComponent<ParticleSystem>().colorOverLifetime;
				Gradient val3 = new Gradient();
				MinMaxGradient color = ((ColorOverLifetimeModule)(ref colorOverLifetime)).color;
				val3.mode = ((MinMaxGradient)(ref color)).gradient.mode;
				color = ((ColorOverLifetimeModule)(ref colorOverLifetime)).color;
				val3.alphaKeys = ((MinMaxGradient)(ref color)).gradient.alphaKeys;
				val3.colorKeys = (GradientColorKey[])(object)new GradientColorKey[3]
				{
					new GradientColorKey
					{
						color = new Color(1f, 1f, 1f),
						time = 0f
					},
					new GradientColorKey
					{
						color = new Color(0.62f, 0.52f, 0.62f),
						time = 0.3f
					},
					new GradientColorKey
					{
						color = new Color(0.43f, 0.42f, 0.66f),
						time = 1f
					}
				};
				((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(val3);
			}
			catch (Exception ex2)
			{
				Log.Warning("ConfusionOnHit:GenerateEffect() ; Could not edit coin orb core.\n" + ex2);
			}
			try
			{
				((Renderer)((Component)val.transform.Find("VFX/CoinParticle")).gameObject.GetComponent<ParticleSystemRenderer>()).material.SetColor("_Color", new Color(0.53f, 0.52f, 0.76f));
			}
			catch (Exception ex3)
			{
				Log.Warning("ConfusionOnHit:GenerateEffect() ; Could not edit coin orb particles.\n" + ex3);
			}
			return val;
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			FriendlyFireManager.ShouldDirectHitProceed += new hook_ShouldDirectHitProceed(FriendlyFireManager_ShouldDirectHitProceed);
			FriendlyFireManager.ShouldSplashHitProceed += new hook_ShouldSplashHitProceed(FriendlyFireManager_ShouldSplashHitProceed);
			FriendlyFireManager.ShouldSeekingProceed += new hook_ShouldSeekingProceed(FriendlyFireManager_ShouldSeekingProceed);
			GlobalEventManager.onServerDamageDealt += GlobalEventManager_onServerDamageDealt;
			CharacterBody.OnBuffFirstStackGained += new hook_OnBuffFirstStackGained(CharacterBody_OnBuffFirstStackGained);
		}

		private static bool FriendlyFireManager_ShouldSeekingProceed(orig_ShouldSeekingProceed orig, HealthComponent victim, TeamIndex attackerTeamIndex)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (victim.body.HasBuff(buffDef))
			{
				return true;
			}
			return orig.Invoke(victim, attackerTeamIndex);
		}

		private static bool FriendlyFireManager_ShouldSplashHitProceed(orig_ShouldSplashHitProceed orig, HealthComponent victim, TeamIndex attackerTeamIndex)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (victim.body.HasBuff(buffDef))
			{
				return true;
			}
			return orig.Invoke(victim, attackerTeamIndex);
		}

		private static bool FriendlyFireManager_ShouldDirectHitProceed(orig_ShouldDirectHitProceed orig, HealthComponent victim, TeamIndex attackerTeamIndex)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (victim.body.HasBuff(buffDef))
			{
				return true;
			}
			return orig.Invoke(victim, attackerTeamIndex);
		}

		private static void GlobalEventManager_onServerDamageDealt(DamageReport obj)
		{
			if (obj.damageInfo.procCoefficient > 0f && !obj.damageInfo.rejected && Object.op_Implicit((Object)(object)obj.attacker) && Object.op_Implicit((Object)(object)obj.attackerMaster) && Object.op_Implicit((Object)(object)obj.attackerMaster.inventory) && Object.op_Implicit((Object)(object)obj.victim) && Object.op_Implicit((Object)(object)obj.victimBody))
			{
				int itemCount = obj.attackerMaster.inventory.GetItemCount(itemDef);
				if (itemCount > 0)
				{
					float num = ConfigManager.ConfusionOnHit_durationBase.Value + (float)(itemCount - 1) * ConfigManager.ConfusionOnHit_durationPerStack.Value;
					_ = ConfigManager.ConfusionOnHit_enemiesAggroed.Value;
					obj.victimBody.AddTimedBuff(buffDef, num);
				}
			}
		}

		private static void CharacterBody_OnBuffFirstStackGained(orig_OnBuffFirstStackGained orig, CharacterBody self, BuffDef buff)
		{
			if ((Object)(object)buff == (Object)(object)buffDef)
			{
				BraqsItems_BetrayedBehavior braqsItems_BetrayedBehavior = ((Component)self).gameObject.AddComponent<BraqsItems_BetrayedBehavior>();
				braqsItems_BetrayedBehavior.body = self;
				((Behaviour)braqsItems_BetrayedBehavior).enabled = true;
			}
			orig.Invoke(self, buff);
		}
	}
	public class ExplosionFrenzy
	{
		public class BraqsItems_ExplosionFrenzyBehavior : ItemBehavior
		{
			private int maxBonus;

			public int bonus;

			private List<BraqsItems_BurnTracker> victims = new List<BraqsItems_BurnTracker>();

			private void Start()
			{
				maxBonus = ConfigManager.ExplosionFrenzy_bonusCapPerStack.Value * (base.stack - 1) + ConfigManager.ExplosionFrenzy_bonusCapBase.Value;
			}

			private void OnDestroy()
			{
			}

			public void AddVictim(GameObject victim)
			{
				BraqsItems_BurnTracker braqsItems_BurnTracker = default(BraqsItems_BurnTracker);
				victim.TryGetComponent<BraqsItems_BurnTracker>(ref braqsItems_BurnTracker);
				if (!Object.op_Implicit((Object)(object)braqsItems_BurnTracker))
				{
					braqsItems_BurnTracker = victim.AddComponent<BraqsItems_BurnTracker>();
					braqsItems_BurnTracker.victimBodyObject = victim;
				}
				else if (victims.Contains(braqsItems_BurnTracker))
				{
					return;
				}
				braqsItems_BurnTracker.AddAttacker(this);
				victims.Add(braqsItems_BurnTracker);
				ApplyBonus();
			}

			public void RemoveVictim(BraqsItems_BurnTracker victim)
			{
				victims.Remove(victim);
				ApplyBonus();
			}

			private void ApplyBonus()
			{
				bonus = Math.Min(victims.Count, maxBonus);
				base.body.RecalculateStats();
			}
		}

		public class BraqsItems_BurnTracker : MonoBehaviour
		{
			public List<BraqsItems_ExplosionFrenzyBehavior> attackers = new List<BraqsItems_ExplosionFrenzyBehavior>();

			public GameObject victimBodyObject;

			private CharacterBody victimCharacterBody;

			public void Start()
			{
				victimCharacterBody = (Object.op_Implicit((Object)(object)victimBodyObject) ? victimBodyObject.GetComponent<CharacterBody>() : null);
			}

			public void OnDestroy()
			{
				foreach (BraqsItems_ExplosionFrenzyBehavior attacker in attackers)
				{
					attacker.RemoveVictim(this);
				}
			}

			public void FixedUpdate()
			{
				if (!Object.op_Implicit((Object)(object)victimCharacterBody) || !victimCharacterBody.HasBuff(Buffs.OnFire))
				{
					Object.Destroy((Object)(object)this);
				}
			}

			public void AddAttacker(BraqsItems_ExplosionFrenzyBehavior attacker)
			{
				if (!attackers.Contains(attacker))
				{
					attackers.Add(attacker);
				}
			}
		}

		public static ItemDef itemDef;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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
			if (ConfigManager.ExplosionFrenzy_isEnabled.Value)
			{
				Log.Info("Initializing My Manifesto Item");
				itemDef = Helpers.GetItemDef("ExplosionFrenzy");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				Hooks();
				Log.Info("My Manifesto Initialized");
			}
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(CharacterBody_OnInventoryChanged);
			BlastAttack.Fire += new hook_Fire(BlastAttack_Fire);
			DotController.onDotInflictedServerGlobal += new OnDotInflictedServerGlobalDelegate(DotController_onDotInflictedServerGlobal);
			Stats.StatsCompEvent.StatsCompRecalc = (EventHandler<Stats.StatsCompRecalcArgs>)Delegate.Combine(Stats.StatsCompEvent.StatsCompRecalc, new EventHandler<Stats.StatsCompRecalcArgs>(StatsCompEvent_StatsCompRecalc));
		}

		private static void DotController_onDotInflictedServerGlobal(DotController dotController, ref InflictDotInfo inflictDotInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			CharacterEvents.BraqsItems_CharacterEventComponent braqsItems_CharacterEventComponent = default(CharacterEvents.BraqsItems_CharacterEventComponent);
			CharacterBody val = default(CharacterBody);
			BraqsItems_ExplosionFrenzyBehavior braqsItems_ExplosionFrenzyBehavior = default(BraqsItems_ExplosionFrenzyBehavior);
			if (((int)inflictDotInfo.dotIndex == 1 || (int)inflictDotInfo.dotIndex == 7) && Object.op_Implicit((Object)(object)dotController.victimBody) && Object.op_Implicit((Object)(object)dotController.victimHealthComponent) && dotController.victimHealthComponent.alive && Object.op_Implicit((Object)(object)dotController.victimBody.master) && ((Component)dotController.victimBody.master).TryGetComponent<CharacterEvents.BraqsItems_CharacterEventComponent>(ref braqsItems_CharacterEventComponent) && inflictDotInfo.attackerObject.TryGetComponent<CharacterBody>(ref val) && ((Component)val).TryGetComponent<BraqsItems_ExplosionFrenzyBehavior>(ref braqsItems_ExplosionFrenzyBehavior))
			{
				braqsItems_ExplosionFrenzyBehavior.AddVictim(dotController.victimObject);
			}
		}

		private static void CharacterBody_OnInventoryChanged(orig_OnInventoryChanged orig, CharacterBody self)
		{
			self.AddItemBehavior<BraqsItems_ExplosionFrenzyBehavior>(self.inventory.GetItemCount(itemDef));
			orig.Invoke(self);
		}

		private static Result BlastAttack_Fire(orig_Fire orig, BlastAttack self)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			Result val = orig.Invoke(self);
			CharacterBody val2 = default(CharacterBody);
			if (Object.op_Implicit((Object)(object)self.attacker) && self.attacker.TryGetComponent<CharacterBody>(ref val2) && Object.op_Implicit((Object)(object)val2.inventory))
			{
				int itemCount = val2.inventory.GetItemCount(itemDef);
				if (itemCount > 0 && val.hitCount > 0)
				{
					float value = ((float)(itemCount - 1) * ConfigManager.ExplosionFrenzy_igniteDamagePerStack.Value + ConfigManager.ExplosionFrenzy_igniteDamageBase.Value) * self.baseDamage;
					for (int i = 0; i < val.hitCount; i++)
					{
						HurtBox hurtBox = val.hitPoints[i].hurtBox;
						if (Object.op_Implicit((Object)(object)hurtBox.healthComponent))
						{
							InflictDotInfo val3 = default(InflictDotInfo);
							val3.victimObject = ((Component)hurtBox.healthComponent).gameObject;
							val3.attackerObject = self.attacker;
							val3.totalDamage = value;
							val3.dotIndex = (DotIndex)1;
							val3.damageMultiplier = 1f;
							InflictDotInfo val4 = val3;
							StrengthenBurnUtils.CheckDotForUpgrade(val2.inventory, ref val4);
							DotController.InflictDot(ref val4);
						}
					}
				}
			}
			return val;
		}

		public static void StatsCompEvent_StatsCompRecalc(object sender, Stats.StatsCompRecalcArgs args)
		{
			BraqsItems_ExplosionFrenzyBehavior braqsItems_ExplosionFrenzyBehavior = default(BraqsItems_ExplosionFrenzyBehavior);
			if (Object.op_Implicit((Object)(object)args.Stats) && NetworkServer.active && Object.op_Implicit((Object)(object)args.Stats.body) && ((Component)args.Stats.body).TryGetComponent<BraqsItems_ExplosionFrenzyBehavior>(ref braqsItems_ExplosionFrenzyBehavior))
			{
				int bonus = braqsItems_ExplosionFrenzyBehavior.bonus;
				if (bonus > 0)
				{
					args.Stats.blastRadiusBoostAdd *= (float)bonus * ConfigManager.ExplosionFrenzy_bonusPerBurn.Value + 1f;
				}
			}
		}
	}
	public class HundredRendingFists
	{
		public class BraqsItems_RendController : MonoBehaviour
		{
			private class DamageStore
			{
				public GameObject attackerObject;

				public float damage;

				public float damageCoefficient;
			}

			private GameObject delayedDamageIndicator;

			private List<DamageStore> damageStores = new List<DamageStore>();

			public float storeBonus;

			private bool firstStackApplied;

			public CharacterBody body;

			public HealthComponent healthComponent;

			private void Start()
			{
				CharacterBody val = default(CharacterBody);
				if (((Component)this).gameObject.TryGetComponent<CharacterBody>(ref val))
				{
					body = val;
					healthComponent = body.healthComponent;
				}
				else
				{
					Object.Destroy((Object)(object)this);
				}
			}

			private void OnDestroy()
			{
				if (Object.op_Implicit((Object)(object)delayedDamageIndicator))
				{
					Object.Destroy((Object)(object)delayedDamageIndicator);
				}
			}

			private void FixedUpdate()
			{
				if (!body.HasBuff(RendDebuff) && firstStackApplied)
				{
					DealStoredDamage();
				}
			}

			public static void ApplyRend(GameObject attacker, CharacterBody victim, DamageInfo damage, float damageCoefficient)
			{
				BraqsItems_RendController braqsItems_RendController = default(BraqsItems_RendController);
				((Component)victim).TryGetComponent<BraqsItems_RendController>(ref braqsItems_RendController);
				if (!Object.op_Implicit((Object)(object)braqsItems_RendController))
				{
					braqsItems_RendController = ((Component)victim).gameObject.AddComponent<BraqsItems_RendController>();
					braqsItems_RendController.body = victim;
				}
				braqsItems_RendController.StoreDamage(attacker, damage, damageCoefficient);
				braqsItems_RendController.firstStackApplied = true;
			}

			private void StoreDamage(GameObject attacker, DamageInfo damageInfo, float damageCoefficient)
			{
				bool flag = true;
				float damage = damageInfo.damage;
				for (int i = 0; i < damageStores.Count; i++)
				{
					if ((Object)(object)damageStores[i].attackerObject == (Object)(object)attacker)
					{
						damageStores[i].damage += damage;
						damageStores[i].damageCoefficient = damageCoefficient;
						flag = false;
					}
				}
				if (flag)
				{
					damageStores.Add(new DamageStore
					{
						attackerObject = attacker,
						damage = damage,
						damageCoefficient = damageCoefficient
					});
				}
				storeBonus += damageInfo.procCoefficient;
				UpdateBuffStacks();
			}

			private void DealStoredDamage()
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: 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_0064: 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_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: 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_0081: Expected O, but got Unknown
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Expected O, but got Unknown
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)healthComponent))
				{
					float num = storeBonus * ConfigManager.HundredRendingFists_storeBonus.Value;
					float scale = Mathf.Min(ConfigManager.HundredRendingFists_storedDamageBase.Value + num, 3f);
					EffectManager.SpawnEffect(delayedDamageActivateEffect, new EffectData
					{
						origin = body.corePosition,
						color = Color32.op_Implicit(Color.white),
						scale = scale
					}, true);
					for (int i = 0; i < damageStores.Count; i++)
					{
						DamageStore damageStore = damageStores[i];
						DamageInfo val = new DamageInfo();
						val.crit = false;
						val.damage = damageStore.damage * (damageStore.damageCoefficient + num);
						val.force = Vector3.zero;
						val.inflictor = ((Component)this).gameObject;
						val.position = body.corePosition;
						val.procCoefficient = 0f;
						val.damageColorIndex = (DamageColorIndex)8;
						val.damageType = DamageTypeCombo.op_Implicit((DamageType)67108864);
						val.attacker = damageStore.attackerObject;
						healthComponent.TakeDamage(val);
					}
				}
				Object.Destroy((Object)(object)this);
			}

			private void UpdateBuffStacks()
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				float value = ConfigManager.HundredRendingFists_rendDuration.Value;
				for (int i = 0; i < body.timedBuffs.Count; i++)
				{
					TimedBuff val = body.timedBuffs[i];
					if (val.buffIndex == RendDebuff.buffIndex)
					{
						val.timer = value;
					}
				}
				for (int j = 0; (float)j < storeBonus - (float)body.GetBuffCount(RendDebuff); j++)
				{
					body.AddTimedBuff(RendDebuff, value);
				}
			}
		}

		public static ItemDef itemDef;

		public static BuffDef RendDebuff;

		private static GameObject delayedDamageActivateEffect;

		private static GameObject delayedDamageEffect;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigManager.HundredRendingFists_isEnabled.Value)
			{
				Log.Info("Initializing North Star Hand Wraps Item");
				itemDef = Helpers.GetItemDef("HundredRendingFists");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				RendDebuff = ScriptableObject.CreateInstance<BuffDef>();
				((Object)RendDebuff).name = "Rend";
				RendDebuff.canStack = true;
				RendDebuff.isHidden = false;
				RendDebuff.isDebuff = true;
				RendDebuff.buffColor = Color.white;
				RendDebuff.isCooldown = false;
				RendDebuff.iconSprite = BraqsItemsMain.assetBundle.LoadAsset<Sprite>("texBuffRendIcon");
				ContentAddition.AddBuffDef(RendDebuff);
				delayedDamageEffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC2/Items/DelayedDamage/DelayedDamageIndicator.prefab").WaitForCompletion();
				delayedDamageActivateEffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/BleedOnHitVoid/FractureImpactEffect.prefab").WaitForCompletion();
				Hooks();
				Log.Info("North Star Hand Wraps Initialized");
			}
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			GlobalEventManager.OnHitEnemy += new hook_OnHitEnemy(GlobalEventManager_OnHitEnemy);
		}

		private static void GlobalEventManager_OnHitEnemy(orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
		{
			CharacterBody val = default(CharacterBody);
			CharacterBody val2 = default(CharacterBody);
			if (!damageInfo.rejected && damageInfo.procCoefficient > 0f && Object.op_Implicit((Object)(object)damageInfo.attacker) && damageInfo.attacker.TryGetComponent<CharacterBody>(ref val) && Object.op_Implicit((Object)(object)val.inventory) && victim.TryGetComponent<CharacterBody>(ref val2) && Object.op_Implicit((Object)(object)val2.healthComponent))
			{
				int itemCount = val.inventory.GetItemCount(itemDef);
				if (itemCount > 0 && Object.op_Implicit((Object)(object)val.master))
				{
					float damageCoefficient = (float)(itemCount - 1) * ConfigManager.HundredRendingFists_storedDamagePerStack.Value + ConfigManager.HundredRendingFists_storedDamageBase.Value;
					BraqsItems_RendController.ApplyRend(damageInfo.attacker, val2, damageInfo, damageCoefficient);
				}
			}
			orig.Invoke(self, damageInfo, victim);
		}
	}
	public class LightningDamageBoost
	{
		public static ItemDef itemDef;

		private static DamageColorIndex chargedColor;

		internal static void Init()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_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_005c: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigManager.InductionCoil_isEnabled.Value)
			{
				Log.Info("Initializing Induction Coil Item");
				itemDef = Helpers.GetItemDef("LightningDamageBoost");
				ItemDisplayRuleDict val = new ItemDisplayRuleDict((ItemDisplayRule[])null);
				ItemAPI.Add(new CustomItem(itemDef, val));
				Hooks();
				chargedColor = ColorsAPI.RegisterDamageColor(new Color(0.37f, 0.5f, 0.924f));
				Log.Info("Induction Coil Initialized");
			}
		}

		private static void Hooks()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			LightningOrb.Begin += new hook_Begin(LightningOrb_Begin);
			VoidLightningOrb.Begin += new hook_Begin(VoidLightningOrb_Begin);
		}

		private static void VoidLightningOrb_Begin(orig_Begin orig, VoidLightningOrb self)
		{
			//IL_003f: 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)
			CharacterBody val = default(CharacterBody);
			if (Object.op_Implicit((Object)(object)self.attacker) && self.attacker.TryGetComponent<CharacterBody>(ref val) && Object.op_Implicit((Object)(object)val.inventory))
			{
				int itemCount = val.inventory.GetItemCount(itemDef);
				if (itemCount > 0)
				{
					self.damageColorIndex = chargedColor;
					self.damageValue *= 1f + (float)(itemCount - 1) * ConfigManager.InductionCoil_damageBonusPerStack.Value + ConfigManager.InductionCoil_damageBonusBase.Value;
				}
			}
			orig.Invoke(self);
		}

		private static void LightningOrb_Begin(orig_Begin orig, LightningOrb self)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing