using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInExUtils.Attributes;
using BepInExUtils.Extensions;
using BepInExUtils.Interfaces;
using BepInExUtils.Logging;
using BepInExUtils.Proxy;
using GlobalEnums;
using GlobalSettings;
using HKSS.NoEnemies.Behaviour;
using HKSS.NoEnemies.Extensions;
using HKSS.NoEnemies.Proxy;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using TeamCherry.SharedUtils;
using UnityEngine;
using UnityEngine.Audio;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("HKSS.NoEnemies")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+1eec5741030a21b63e6179b19fb810889098c7bd")]
[assembly: AssemblyProduct("HKSS.NoEnemies")]
[assembly: AssemblyTitle("HKSS.NoEnemies")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace HKSS.NoEnemies
{
	[BepInUtils("io.github.ykysnk.HKSS.NoEnemies", "No Enemies", "0.0.7")]
	[BepInDependency("io.github.ykysnk.BepinExUtils", "1.0.0")]
	[BepInProcess("Hollow Knight Silksong.exe")]
	[ConfigBind<NoEnemiesMode>("Mode", "Options", NoEnemiesMode.BeGone, "No enemies working modes.")]
	[ConfigBind<bool>("RandomCorpseSplat", "Options", false, "Random corpse splat in the maps.")]
	[BepInPlugin("io.github.ykysnk.HKSS.NoEnemies", "No Enemies", "0.0.7")]
	public class Main : BaseUnityPlugin, IBepInUtils
	{
		private const string SectionOptions = "Options";

		private const string Version = "0.0.7";

		private static Main? _instance;

		private readonly Harmony _harmony = new Harmony("io.github.ykysnk.HKSS.NoEnemies");

		public void Init()
		{
		}

		public Main()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_002c: 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)
			//IL_0047: Expected O, but got Unknown
			//IL_0047: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0077: Expected O, but got Unknown
			_instance = this;
			Configs._Mode = ((BaseUnityPlugin)this).Config.Bind<NoEnemiesMode>(new ConfigDefinition("Options", "Mode"), NoEnemiesMode.BeGone, new ConfigDescription("No enemies working modes.", (AcceptableValueBase)null, Array.Empty<object>()));
			Configs._RandomCorpseSplat = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Options", "RandomCorpseSplat"), false, new ConfigDescription("Random corpse splat in the maps.", (AcceptableValueBase)null, Array.Empty<object>()));
			Configs.Init();
			Utils.Logger.Info((object)"Plugin No Enemies is loaded, version 0.0.7");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			Init();
		}
	}
	public enum NoEnemiesMode
	{
		Off,
		BeGone,
		KillWhenTryAttack
	}
	public static class Utils
	{
		internal const string GameName = "Hollow Knight Silksong.exe";

		internal const string Guid = "io.github.ykysnk.HKSS.NoEnemies";

		internal const string Name = "No Enemies";

		internal const string Version = "0.0.7";

		private static Logger? _logger;

		public static Logger Logger
		{
			get
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				object obj = _logger;
				if (obj == null)
				{
					Logger val = new Logger("No Enemies");
					_logger = val;
					obj = (object)val;
				}
				return (Logger)obj;
			}
		}
	}
	public static class Configs
	{
		public delegate void OnModeValueChangedEvent(NoEnemiesMode oldValue, NoEnemiesMode newValue);

		public delegate void OnRandomCorpseSplatValueChangedEvent(bool oldValue, bool newValue);

		internal static ConfigEntry<NoEnemiesMode>? _Mode;

		internal static ConfigEntry<bool>? _RandomCorpseSplat;

		private static NoEnemiesMode? _oldMode;

		private static bool? _oldRandomCorpseSplat;

		public static NoEnemiesMode Mode
		{
			get
			{
				return _Mode?.Value ?? NoEnemiesMode.Off;
			}
			set
			{
				if (_Mode != null)
				{
					_Mode.Value = value;
				}
			}
		}

		public static bool RandomCorpseSplat
		{
			get
			{
				return _RandomCorpseSplat?.Value ?? false;
			}
			set
			{
				if (_RandomCorpseSplat != null)
				{
					_RandomCorpseSplat.Value = value;
				}
			}
		}

		public static event OnModeValueChangedEvent? OnModeValueChanged;

		public static event OnRandomCorpseSplatValueChangedEvent? OnRandomCorpseSplatValueChanged;

		internal static void Init()
		{
			_oldMode = _Mode?.Value;
			ConfigEntry<NoEnemiesMode>? mode = _Mode;
			if (mode != null)
			{
				mode.SettingChanged += delegate
				{
					Configs.OnModeValueChanged?.Invoke(_oldMode.GetValueOrDefault(), _Mode.Value);
					_oldMode = _Mode.Value;
				};
			}
			_oldRandomCorpseSplat = _RandomCorpseSplat?.Value;
			ConfigEntry<bool>? randomCorpseSplat = _RandomCorpseSplat;
			if (randomCorpseSplat != null)
			{
				randomCorpseSplat.SettingChanged += delegate
				{
					Configs.OnRandomCorpseSplatValueChanged?.Invoke(_oldRandomCorpseSplat.GetValueOrDefault(), _RandomCorpseSplat.Value);
					_oldRandomCorpseSplat = _RandomCorpseSplat.Value;
				};
			}
		}
	}
}
namespace HKSS.NoEnemies.Proxy
{
	[PublicAPI]
	public class HealthManagerItemDropGroupProxy : ClassProxy
	{
		private const string ClassName = "HealthManager+ItemDropGroup";

		public float TotalProbability
		{
			get
			{
				return ObjectExtensions.GetFieldValue<float>(((ClassProxy)this).Native, "TotalProbability");
			}
			set
			{
				ObjectExtensions.SetFieldValue<float>(((ClassProxy)this).Native, "TotalProbability", value);
			}
		}

		public List<HealthManagerItemDropProbabilityProxy> Drops
		{
			get
			{
				IList fieldValue = ObjectExtensions.GetFieldValue<IList>(((ClassProxy)this).Native, "Drops");
				if (fieldValue != null)
				{
					return (from x in fieldValue.OfType<object>()
						select new HealthManagerItemDropProbabilityProxy(x)).ToList();
				}
				return new List<HealthManagerItemDropProbabilityProxy>();
			}
			set
			{
				ObjectExtensions.SetFieldValue<List<object>>(((ClassProxy)this).Native, "Drops", value.Select((HealthManagerItemDropProbabilityProxy x) => ((ClassProxy)x).Native).ToList());
			}
		}

		public HealthManagerItemDropGroupProxy()
			: base("HealthManager+ItemDropGroup")
		{
		}

		public HealthManagerItemDropGroupProxy(object obj)
			: base(obj, "HealthManager+ItemDropGroup")
		{
		}

		public ItemDropProbabilityCopy[] ToDropsCopyArray()
		{
			return Drops.Select((HealthManagerItemDropProbabilityProxy x) => new ItemDropProbabilityCopy
			{
				item = x.item,
				Amount = x.Amount,
				CustomPickupPrefab = x.CustomPickupPrefab,
				LimitActiveInScene = x.LimitActiveInScene
			}).ToArray();
		}
	}
	[PublicAPI]
	public class HealthManagerItemDropProbabilityProxy : ClassProxy
	{
		private const string ClassName = "HealthManager+ItemDropProbability";

		public SavedItem item
		{
			get
			{
				return ObjectExtensions.GetFieldValue<SavedItem>(((ClassProxy)this).Native, "item");
			}
			set
			{
				ObjectExtensions.SetFieldValue<SavedItem>(((ClassProxy)this).Native, "item", value);
			}
		}

		public MinMaxInt Amount
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				return ObjectExtensions.GetFieldValue<MinMaxInt>(((ClassProxy)this).Native, "amount");
			}
			set
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				ObjectExtensions.SetFieldValue<MinMaxInt>(((ClassProxy)this).Native, "amount", value);
			}
		}

		public CollectableItemPickup CustomPickupPrefab
		{
			get
			{
				return ObjectExtensions.GetFieldValue<CollectableItemPickup>(((ClassProxy)this).Native, "customPickupPrefab");
			}
			set
			{
				ObjectExtensions.SetFieldValue<CollectableItemPickup>(((ClassProxy)this).Native, "customPickupPrefab", value);
			}
		}

		public int LimitActiveInScene
		{
			get
			{
				return ObjectExtensions.GetFieldValue<int>(((ClassProxy)this).Native, "limitActiveInScene");
			}
			set
			{
				ObjectExtensions.SetFieldValue<int>(((ClassProxy)this).Native, "limitActiveInScene", value);
			}
		}

		public HealthManagerItemDropProbabilityProxy()
			: base("HealthManager+ItemDropProbability")
		{
		}

		public HealthManagerItemDropProbabilityProxy(object obj)
			: base(obj, "HealthManager+ItemDropProbability")
		{
		}
	}
	[Serializable]
	public class ItemDropProbabilityCopy : ProbabilityBase<SavedItem>
	{
		[SerializeField]
		internal SavedItem? item;

		public MinMaxInt Amount = new MinMaxInt(1, 1);

		public CollectableItemPickup? CustomPickupPrefab;

		public int LimitActiveInScene;

		public override SavedItem Item => item;
	}
}
namespace HKSS.NoEnemies.Patches
{
	[HarmonyPatch(typeof(HealthManager))]
	internal class HealthManagerPatches
	{
		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		private static void Awake(HealthManager __instance)
		{
			Utils.Logger.Debug((object)$"__instance {__instance} {((Object)((Component)__instance).gameObject).name}");
			NoEnemiesController noEnemiesController = default(NoEnemiesController);
			NoEnemiesController noEnemiesController2 = ((!((Component)__instance).gameObject.TryGetComponent<NoEnemiesController>(ref noEnemiesController)) ? ((Component)__instance).gameObject.AddComponent<NoEnemiesController>() : noEnemiesController);
			Utils.Logger.Debug((object)$"controller {noEnemiesController2}");
			noEnemiesController2.HealthManager = __instance;
		}
	}
	[HarmonyPatch(typeof(HeroBox))]
	internal class HeroBoxPatches
	{
		[HarmonyPatch("CheckForDamage")]
		private static bool CheckForDamage(HeroBox __instance, GameObject otherGameObject)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)otherGameObject))
			{
				return true;
			}
			Utils.Logger.Debug((object)("TakeDamage by " + GameObjectExtensions.FullName(otherGameObject.gameObject)));
			if (Configs.Mode != NoEnemiesMode.KillWhenTryAttack)
			{
				return true;
			}
			GameObject val = (Object.op_Implicit((Object)(object)otherGameObject.transform.parent) ? ((Component)otherGameObject.transform.parent).gameObject : null);
			GameObject val2 = (Object.op_Implicit((Object)(object)otherGameObject.transform.root) ? ((Component)otherGameObject.transform.root).gameObject : null);
			HealthManager val3 = default(HealthManager);
			HealthManager val4 = (otherGameObject.TryGetComponent<HealthManager>(ref val3) ? val3 : ((val != null && val.TryGetComponent<HealthManager>(ref val3)) ? val3 : ((val2 != null && val2.TryGetComponent<HealthManager>(ref val3)) ? val3 : null)));
			if (!Object.op_Implicit((Object)(object)val4))
			{
				return true;
			}
			Utils.Logger.Debug((object)(GameObjectExtensions.FullName(otherGameObject.gameObject) + " Trying to attack"));
			val4.DieDropFling(NoEnemiesController.HitInstance.ToolDamageFlags, bool1: true);
			val4.BeGone(null, NoEnemiesController.HitInstance.AttackType, NoEnemiesController.HitInstance.NailElement, NoEnemiesController.HitInstance.Source, NoEnemiesController.HitInstance.IgnoreInvulnerable, 0f);
			return false;
		}
	}
	[HarmonyPatch(typeof(HeroController))]
	internal static class HeroControllerPatches
	{
		[HarmonyPatch("TakeDamage")]
		[HarmonyPrefix]
		private static bool TakeDamage(HeroController __instance, GameObject go, CollisionSide damageSide, int damageAmount, HazardType hazardType, DamagePropertyFlags damagePropertyFlags)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)go))
			{
				return true;
			}
			Utils.Logger.Debug((object)("TakeDamage by " + GameObjectExtensions.FullName(go.gameObject)));
			if (Configs.Mode != NoEnemiesMode.KillWhenTryAttack)
			{
				return true;
			}
			GameObject val = (Object.op_Implicit((Object)(object)go.transform.parent) ? ((Component)go.transform.parent).gameObject : null);
			GameObject val2 = (Object.op_Implicit((Object)(object)go.transform.root) ? ((Component)go.transform.root).gameObject : null);
			HealthManager val3 = default(HealthManager);
			HealthManager val4 = (go.TryGetComponent<HealthManager>(ref val3) ? val3 : ((val != null && val.TryGetComponent<HealthManager>(ref val3)) ? val3 : ((val2 != null && val2.TryGetComponent<HealthManager>(ref val3)) ? val3 : null)));
			if (!Object.op_Implicit((Object)(object)val4))
			{
				return true;
			}
			Utils.Logger.Debug((object)(GameObjectExtensions.FullName(go.gameObject) + " Trying to attack"));
			val4.DieDropFling(NoEnemiesController.HitInstance.ToolDamageFlags, bool1: true);
			val4.BeGone(null, NoEnemiesController.HitInstance.AttackType, NoEnemiesController.HitInstance.NailElement, NoEnemiesController.HitInstance.Source, NoEnemiesController.HitInstance.IgnoreInvulnerable, 0f);
			__instance.SetState((ActorStates)1);
			__instance.AcceptInput();
			return false;
		}
	}
}
namespace HKSS.NoEnemies.Extensions
{
	[AccessExtensions]
	[AccessInstance<ActiveCorpse>]
	[AccessField<tk2dSprite>("sprite")]
	[PublicAPI]
	public static class ActiveCorpseExtensions
	{
		public sealed class <>E__0
		{
			public tk2dSprite sprite
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}
		}

		[SpecialName]
		public static tk2dSprite get_sprite(ActiveCorpse instance)
		{
			return ObjectExtensions.GetFieldValue<tk2dSprite>((object)instance, "sprite");
		}

		[SpecialName]
		public static void set_sprite(ActiveCorpse instance, tk2dSprite value)
		{
			ObjectExtensions.SetFieldValue<tk2dSprite>((object)instance, "sprite", value);
		}
	}
	[AccessExtensions]
	[AccessInstance<EnemyDeathEffects>]
	[AccessField<bool>("didFire")]
	[AccessField<bool>("isCorpseRecyclable")]
	[AccessField<string>("awardAchievement")]
	[AccessField<AudioMixerSnapshot>("audioSnapshotOnDeath")]
	[AccessField<string>("sendEventRegister")]
	[AccessField<bool>("recycle")]
	[AccessMethod("ShakeCameraIfVisible", new Type[] { })]
	[AccessMethod("EmitEffects", new Type[] { typeof(GameObject) })]
	public static class EnemyDeathEffectsExtensions
	{
		public sealed class <>E__0
		{
			public bool didFire
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public bool isCorpseRecyclable
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public string awardAchievement
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public AudioMixerSnapshot audioSnapshotOnDeath
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public string sendEventRegister
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public bool recycle
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public void ShakeCameraIfVisible()
			{
				throw null;
			}

			public void EmitEffects(GameObject gameObject1)
			{
				throw null;
			}
		}

		public static void ReceiveBeGoneEvent(this EnemyDeathEffects effects, float? attackDirection, AttackTypes attackType, NailElements nailElement, GameObject damageSource, float corpseFlingMultiplier, bool resetDeathEvent, Action<Transform>? onCorpseBegin, out bool didCallCorpseBegin, out GameObject? corpseObj)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Invalid comparison between Unknown and I4
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			didCallCorpseBegin = false;
			corpseObj = null;
			if (effects != null && get_didFire(effects) && !get_isCorpseRecyclable(effects))
			{
				return;
			}
			set_didFire(effects, value: true);
			effects.RecordKillForJournal();
			if ((double)corpseFlingMultiplier > 1.350000023841858)
			{
				corpseFlingMultiplier = 1.35f;
			}
			int num;
			if ((int)attackType != 5)
			{
				if ((int)attackType == 8)
				{
					if (Configs.Mode != NoEnemiesMode.BeGone)
					{
						effects.ShakeCameraIfVisible();
					}
					if (Object.op_Implicit((Object)(object)Corpse.EnemyLavaDeath))
					{
						Extensions.SetPosition2D(ObjectPoolExtensions.Spawn(Corpse.EnemyLavaDeath).transform, Vector2.op_Implicit(((Component)effects).transform.TransformPoint(effects.effectOrigin)));
					}
					goto IL_00e4;
				}
				num = (((int)attackType == 3) ? 1 : 0);
			}
			else
			{
				num = 1;
			}
			corpseObj = effects.EmitCorpse(attackDirection, corpseFlingMultiplier, attackType, nailElement, damageSource, onCorpseBegin, out didCallCorpseBegin);
			Utils.Logger.Debug((object)$"corpseObj is spawn: {MonoBehaviourExtensions.FullName((MonoBehaviour)(object)effects)} {corpseObj} {GameObjectExtensions.FullName(corpseObj)}");
			if (num == 0 && Configs.Mode != NoEnemiesMode.BeGone)
			{
				effects.EmitEffects(corpseObj);
			}
			goto IL_00e4;
			IL_00e4:
			GameManager instance = GameManager.instance;
			if (!string.IsNullOrEmpty(effects.setPlayerDataBool))
			{
				instance.playerData.SetBool(effects.setPlayerDataBool, true);
			}
			if (!string.IsNullOrWhiteSpace(get_awardAchievement(effects)))
			{
				instance.AwardAchievement(get_awardAchievement(effects));
			}
			if (!effects.doNotSetHasKilled)
			{
				instance.playerData.SetBool("hasKilled", true);
			}
			if (Object.op_Implicit((Object)(object)get_audioSnapshotOnDeath(effects)))
			{
				get_audioSnapshotOnDeath(effects).TransitionTo(2f);
			}
			if (!string.IsNullOrEmpty(get_sendEventRegister(effects)))
			{
				EventRegister.SendEvent(get_sendEventRegister(effects), (GameObject)null);
			}
			if (!resetDeathEvent)
			{
				PersistentBoolItem component = ((Component)effects).GetComponent<PersistentBoolItem>();
				if (Object.op_Implicit((Object)(object)component))
				{
					((PersistentItem<bool>)(object)component).SaveState();
				}
				if (get_recycle(effects))
				{
					PlayMakerFSM val = FSMUtility.LocateFSM(((Component)effects).gameObject, "health_manager_enemy");
					if (Object.op_Implicit((Object)(object)val))
					{
						val.FsmVariables.GetFsmBool("Activated").Value = false;
					}
					HealthManager component2 = ((Component)effects).GetComponent<HealthManager>();
					if (Object.op_Implicit((Object)(object)component2))
					{
						component2.SetIsDead(false);
					}
					set_didFire(effects, value: false);
					ObjectPoolExtensions.Recycle(((Component)effects).gameObject);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)effects).gameObject);
				}
			}
			else
			{
				FSMUtility.SendEventToGameObject(((Component)effects).gameObject, "CENTIPEDE DEATH", false);
				set_didFire(effects, value: false);
			}
		}

		public static GameObject EmitCorpse(this EnemyDeathEffects instance, float? attackDirection, float flingMultiplier, AttackTypes attackType, NailElements nailElement, GameObject damageSource, Action<Transform>? onCorpseBegin, out bool didCallCorpseBegin)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			object[] array = new object[7] { attackDirection, flingMultiplier, attackType, nailElement, damageSource, onCorpseBegin, null };
			MethodInfo methodInfo = AccessTools.Method(((object)instance).GetType(), "EmitCorpse", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				throw new MethodAccessException("EmitCorpse method not found.");
			}
			object? obj = methodInfo.Invoke(instance, array);
			object valueOrDefault = ListExtensions.GetValueOrDefault<object>(array, 6);
			didCallCorpseBegin = valueOrDefault is bool && (bool)valueOrDefault;
			return (GameObject)(((obj is GameObject) ? obj : null) ?? throw new MethodAccessException("EmitCorpse method return value is not GameObject."));
		}

		[SpecialName]
		public static bool get_didFire(EnemyDeathEffects instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "didFire");
		}

		[SpecialName]
		public static void set_didFire(EnemyDeathEffects instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "didFire", value);
		}

		[SpecialName]
		public static bool get_isCorpseRecyclable(EnemyDeathEffects instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "isCorpseRecyclable");
		}

		[SpecialName]
		public static void set_isCorpseRecyclable(EnemyDeathEffects instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "isCorpseRecyclable", value);
		}

		[SpecialName]
		public static string get_awardAchievement(EnemyDeathEffects instance)
		{
			return ObjectExtensions.GetFieldValue<string>((object)instance, "awardAchievement");
		}

		[SpecialName]
		public static void set_awardAchievement(EnemyDeathEffects instance, string value)
		{
			ObjectExtensions.SetFieldValue<string>((object)instance, "awardAchievement", value);
		}

		[SpecialName]
		public static AudioMixerSnapshot get_audioSnapshotOnDeath(EnemyDeathEffects instance)
		{
			return ObjectExtensions.GetFieldValue<AudioMixerSnapshot>((object)instance, "audioSnapshotOnDeath");
		}

		[SpecialName]
		public static void set_audioSnapshotOnDeath(EnemyDeathEffects instance, AudioMixerSnapshot value)
		{
			ObjectExtensions.SetFieldValue<AudioMixerSnapshot>((object)instance, "audioSnapshotOnDeath", value);
		}

		[SpecialName]
		public static string get_sendEventRegister(EnemyDeathEffects instance)
		{
			return ObjectExtensions.GetFieldValue<string>((object)instance, "sendEventRegister");
		}

		[SpecialName]
		public static void set_sendEventRegister(EnemyDeathEffects instance, string value)
		{
			ObjectExtensions.SetFieldValue<string>((object)instance, "sendEventRegister", value);
		}

		[SpecialName]
		public static bool get_recycle(EnemyDeathEffects instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "recycle");
		}

		[SpecialName]
		public static void set_recycle(EnemyDeathEffects instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "recycle", value);
		}

		[SpecialName]
		public static void ShakeCameraIfVisible(this EnemyDeathEffects instance)
		{
			ObjectExtensions.MethodInvoke((object)instance, "ShakeCameraIfVisible", Array.Empty<object>());
		}

		[SpecialName]
		public static void EmitEffects(this EnemyDeathEffects instance, GameObject gameObject1)
		{
			ObjectExtensions.MethodInvoke((object)instance, "EmitEffects", new object[1] { gameObject1 });
		}
	}
	[AccessExtensions]
	[AccessInstance<HealthManager>]
	[AccessField<bool>("hasBlackThreadState")]
	[AccessField<BlackThreadState>("blackThreadState")]
	[AccessField<GameObject>("battleScene")]
	[AccessField<bool>("bigEnemyDeath")]
	[AccessField<bool>("preventDeathAfterHero")]
	[AccessField<int>("shellShardDrops")]
	[AccessField<int>("smallGeoDrops")]
	[AccessField<int>("mediumGeoDrops")]
	[AccessField<int>("largeGeoDrops")]
	[AccessField<int>("largeSmoothGeoDrops")]
	[AccessField<float[]>("_shellShardMultiplierArray")]
	[AccessField<bool>("megaFlingGeo")]
	[AccessField<QueuedDropItem>("queuedDropItem")]
	[AccessField<GameObject>("zeroHPEventOverride")]
	[AccessField<DamageHero>("damageHero")]
	[AccessField<bool>("notifiedBattleScene")]
	[AccessField<AudioMixerSnapshot>("deathAudioSnapshot")]
	[AccessField<GameObject>("sendKilledTo")]
	[AccessField<GameObject>("corpseSplatPrefab")]
	[AccessField<Vector3>("effectOrigin")]
	[AccessField<EnemyDeathEffects>("enemyDeathEffects")]
	[AccessField<EventRelayResponder>("corpseEventResponder")]
	[AccessMethod("Invincible", new Type[] { typeof(HitInstance) })]
	[AccessMethod("TakeDamage", new Type[] { typeof(HitInstance) })]
	[AccessMethod("DieDropFling", new Type[]
	{
		typeof(ToolDamageFlags),
		typeof(bool)
	})]
	[AccessMethod("SpawnCurrency", new Type[]
	{
		typeof(Transform),
		typeof(float),
		typeof(float),
		typeof(float),
		typeof(float),
		typeof(int),
		typeof(int),
		typeof(int),
		typeof(int),
		typeof(bool),
		typeof(int),
		typeof(bool)
	})]
	[AccessMethod("SpawnQueuedItemDrop", new Type[]
	{
		typeof(QueuedDropItem),
		typeof(Transform)
	})]
	[AccessMethod("SpawnItemDrop", new Type[]
	{
		typeof(SavedItem),
		typeof(int),
		typeof(CollectableItemPickup),
		typeof(Transform),
		typeof(int)
	})]
	[AccessMethod("NonFatalHit", new Type[] { typeof(bool) })]
	[PublicAPI]
	public static class HealthManagerExtensions
	{
		public sealed class <>E__0
		{
			[PublicAPI]
			public List<HealthManagerItemDropGroupProxy> itemDropGroups
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}
		}

		public sealed class <>E__1
		{
			public bool hasBlackThreadState
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public BlackThreadState blackThreadState
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public GameObject battleScene
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public bool bigEnemyDeath
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public bool preventDeathAfterHero
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public int shellShardDrops
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public int smallGeoDrops
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public int mediumGeoDrops
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public int largeGeoDrops
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public int largeSmoothGeoDrops
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public float[] _shellShardMultiplierArray
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public bool megaFlingGeo
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public QueuedDropItem queuedDropItem
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public GameObject zeroHPEventOverride
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public DamageHero damageHero
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public bool notifiedBattleScene
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public AudioMixerSnapshot deathAudioSnapshot
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public GameObject sendKilledTo
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public GameObject corpseSplatPrefab
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public Vector3 effectOrigin
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public EnemyDeathEffects enemyDeathEffects
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public EventRelayResponder corpseEventResponder
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public void Invincible(HitInstance hitInstance1)
			{
				throw null;
			}

			public void TakeDamage(HitInstance hitInstance1)
			{
				throw null;
			}

			public void DieDropFling(ToolDamageFlags toolDamageFlags1, bool bool1)
			{
				throw null;
			}

			public void SpawnCurrency(Transform transform1, float float1, float float2, float float3, float float4, int int1, int int2, int int3, int int4, bool bool1, int int5, bool bool2)
			{
				throw null;
			}

			public void SpawnQueuedItemDrop(QueuedDropItem healthManager_QueuedDropItem1, Transform transform1)
			{
				throw null;
			}

			public void SpawnItemDrop(SavedItem savedItem1, int int1, CollectableItemPickup collectableItemPickup1, Transform transform1, int int2)
			{
				throw null;
			}

			public void NonFatalHit(bool bool1)
			{
				throw null;
			}
		}

		public static void BeGone(this HealthManager instance, float? attackDirection, AttackTypes attackType, NailElements nailElement, GameObject damageSource, bool ignoreEvasion = false, float corpseFlingMultiplier = 1f, bool overrideSpecialDeath = false, bool disallowDropFling = false)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Invalid comparison between Unknown and I4
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Invalid comparison between Unknown and I4
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Invalid comparison between Unknown and I4
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_0497: Invalid comparison between Unknown and I4
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04de: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_060c: Unknown result type (might be due to invalid IL or missing references)
			HealthManager instance2 = instance;
			Utils.Logger.Debug((object)("BeGone is called: " + GameObjectExtensions.FullName(((Component)instance2).gameObject)));
			instance2.hp = -1;
			if (instance2.isDead)
			{
				return;
			}
			instance2.CancelAllLagHits();
			float minCorpseFlingMagnitudeMult = Corpse.MinCorpseFlingMagnitudeMult;
			if (corpseFlingMultiplier < minCorpseFlingMagnitudeMult && Math.Abs(corpseFlingMultiplier) > Mathf.Epsilon)
			{
				corpseFlingMultiplier = minCorpseFlingMagnitudeMult;
			}
			Action<Transform> action = null;
			if (!disallowDropFling && (int)attackType != 5 && (int)GameManager.instance.GetCurrentMapZoneEnum() != 33)
			{
				int smallGeoExtra = 0;
				int mediumGeoExtra = 0;
				int largeGeoExtra = 0;
				int largeSmoothGeoExtra = 0;
				int shellShardExtra = 0;
				int shellShardBase = get_shellShardDrops(instance2);
				bool thiefCharmEquipped = ((ToolBase)Gameplay.ThiefCharmTool).IsEquipped;
				if (thiefCharmEquipped)
				{
					smallGeoExtra = Mathf.CeilToInt((float)get_smallGeoDrops(instance2) * Gameplay.ThiefCharmGeoSmallIncrease);
					mediumGeoExtra = Mathf.CeilToInt((float)get_mediumGeoDrops(instance2) * Gameplay.ThiefCharmGeoMedIncrease);
					largeGeoExtra = Mathf.CeilToInt((float)get_largeGeoDrops(instance2) * Gameplay.ThiefCharmGeoLargeIncrease);
					largeSmoothGeoExtra = Mathf.CeilToInt((float)get_largeSmoothGeoDrops(instance2) * Gameplay.ThiefCharmGeoLargeIncrease);
				}
				float num = get__shellShardMultiplierArray(instance2)[Random.Range(0, get__shellShardMultiplierArray(instance2).Length)];
				int num2 = Mathf.CeilToInt((float)shellShardBase * num - (float)shellShardBase);
				if (num2 > 8)
				{
					num2 = 8;
				}
				shellShardBase += num2;
				ToolItem boneNecklaceTool = Gameplay.BoneNecklaceTool;
				if (Object.op_Implicit((Object)(object)boneNecklaceTool) && ((ToolBase)boneNecklaceTool).IsEquipped)
				{
					shellShardExtra = Mathf.CeilToInt((float)shellShardBase * Gameplay.BoneNecklaceShellshardIncrease);
				}
				int dropFlingAngleMin = (get_megaFlingGeo(instance2) ? 65 : 80);
				int dropFlingAngleMax = (get_megaFlingGeo(instance2) ? 115 : 100);
				int dropFlingSpeedMin = (get_megaFlingGeo(instance2) ? 30 : 15);
				int dropFlingSpeedMax = (get_megaFlingGeo(instance2) ? 45 : 30);
				Transform sourceTransform = ((Component)instance2).transform;
				QueuedDropItem queuedItem = get_queuedDropItem(instance2);
				QueuedDropItem val = get_queuedDropItem(instance2);
				((QueuedDropItem)(ref val)).Reset();
				action = delegate(Transform spawnPoint)
				{
					//IL_014b: Unknown result type (might be due to invalid IL or missing references)
					Transform spawnPoint2 = spawnPoint;
					Utils.Logger.Debug((object)$"onCorpseBegin is called: {GameObjectExtensions.FullName(((Component)instance2).gameObject)} {TransformExtensions.FullName(spawnPoint2)} {spawnPoint2}");
					instance2.SpawnCurrency(spawnPoint2, dropFlingSpeedMin, dropFlingSpeedMax, dropFlingAngleMin, dropFlingAngleMax, get_smallGeoDrops(instance2), get_mediumGeoDrops(instance2), get_largeGeoDrops(instance2), get_largeSmoothGeoDrops(instance2), bool1: false, shellShardBase, bool2: false);
					instance2.SpawnCurrency(spawnPoint2, dropFlingSpeedMin, dropFlingSpeedMax, dropFlingAngleMin, dropFlingAngleMax, 0, 0, 0, 0, bool1: false, shellShardExtra, bool2: true);
					if (smallGeoExtra > 0 || mediumGeoExtra > 0 || largeGeoExtra > 0 || largeSmoothGeoExtra > 0)
					{
						if ((Object)(object)spawnPoint2 == (Object)(object)sourceTransform)
						{
							SpawnExtraGeo();
						}
						else
						{
							Extensions.ExecuteDelayed(((Component)spawnPoint2).GetComponent<MonoBehaviour>(), 0.2f, (Action)SpawnExtraGeo);
						}
					}
					instance2.SpawnQueuedItemDrop(queuedItem, spawnPoint2);
					Utils.Logger.Debug((object)$"instance.itemDropGroups: {get_itemDropGroups(instance2)} {get_itemDropGroups(instance2).Count}");
					foreach (ItemDropProbabilityCopy item in from itemDropGroup in get_itemDropGroups(instance2)
						where itemDropGroup.Drops.Count > 0 && (double)itemDropGroup.TotalProbability >= 1.0
						select (ItemDropProbabilityCopy)(object)Probability.GetRandomItemRootByProbability<ItemDropProbabilityCopy, SavedItem>(itemDropGroup.ToDropsCopyArray(), (float[])null))
					{
						instance2.SpawnItemDrop(((ProbabilityBase<SavedItem>)(object)item).Item, ((MinMaxInt)(ref item.Amount)).GetRandomValue(true), item.CustomPickupPrefab, spawnPoint2, item.LimitActiveInScene);
					}
					void SpawnExtraGeo()
					{
						//IL_000d: Unknown result type (might be due to invalid IL or missing references)
						//IL_0012: 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)
						if (thiefCharmEquipped)
						{
							AudioEvent thiefCharmEnemyDeathAudio = Gameplay.ThiefCharmEnemyDeathAudio;
							((AudioEvent)(ref thiefCharmEnemyDeathAudio)).SpawnAndPlayOneShot(spawnPoint2.position, (Action)null);
						}
						instance2.SpawnCurrency(spawnPoint2, dropFlingSpeedMin, dropFlingSpeedMax, dropFlingAngleMin, dropFlingAngleMax, smallGeoExtra, mediumGeoExtra, largeGeoExtra, largeSmoothGeoExtra, bool1: true, 0, bool2: false);
					}
				};
			}
			if (!overrideSpecialDeath)
			{
				GameObject val2 = (Object.op_Implicit((Object)(object)get_zeroHPEventOverride(instance2)) ? get_zeroHPEventOverride(instance2) : ((Component)instance2).gameObject);
				FSMUtility.SendEventToGameObject(val2, "ZERO HP", false);
				if (Object.op_Implicit((Object)(object)get_blackThreadState(instance2)))
				{
					get_blackThreadState(instance2).CancelAttack();
				}
				if ((int)attackType == 8)
				{
					FSMUtility.SendEventToGameObject(val2, "LAVA DEATH", false);
				}
				Utils.Logger.Debug((object)$"the obj death: {val2} {GameObjectExtensions.FullName(val2)} instance.hasSpecialDeath {instance2.hasSpecialDeath}");
				if (instance2.hasSpecialDeath)
				{
					instance2.NonFatalHit(ignoreEvasion);
					action?.Invoke(((Component)instance2).transform);
					return;
				}
			}
			instance2.isDead = true;
			if (Object.op_Implicit((Object)(object)get_damageHero(instance2)))
			{
				get_damageHero(instance2).damageDealt = 0;
			}
			if (Object.op_Implicit((Object)(object)get_battleScene(instance2)) && !get_notifiedBattleScene(instance2))
			{
				BattleScene component = get_battleScene(instance2).GetComponent<BattleScene>();
				if (Object.op_Implicit((Object)(object)component))
				{
					if (!get_bigEnemyDeath(instance2))
					{
						component.DecrementEnemy();
					}
					else
					{
						component.DecrementBigEnemy();
					}
				}
			}
			if (Object.op_Implicit((Object)(object)get_deathAudioSnapshot(instance2)))
			{
				get_deathAudioSnapshot(instance2).TransitionTo(6f);
			}
			if (Object.op_Implicit((Object)(object)get_sendKilledTo(instance2)))
			{
				FSMUtility.SendEventToGameObject(get_sendKilledTo(instance2), "KILLED", false);
			}
			instance2.SendDeathEvent();
			Utils.Logger.Debug((object)$"the obj: {((Component)instance2).gameObject} {GameObjectExtensions.FullName(((Component)instance2).gameObject)}");
			if (Configs.RandomCorpseSplat)
			{
				ObjectPoolExtensions.Spawn(get_corpseSplatPrefab(instance2), ((Component)instance2).transform.position + get_effectOrigin(instance2), Quaternion.identity);
			}
			if ((int)attackType == 4)
			{
				if (Configs.Mode != NoEnemiesMode.BeGone)
				{
					GameCameras.instance.cameraShakeFSM.SendEvent("AverageShake");
					ObjectPoolExtensions.Spawn(get_corpseSplatPrefab(instance2), ((Component)instance2).transform.position + get_effectOrigin(instance2), Quaternion.identity);
					if (Object.op_Implicit((Object)(object)get_enemyDeathEffects(instance2)))
					{
						get_enemyDeathEffects(instance2).EmitSound();
					}
				}
				((Component)instance2).gameObject.SetActive(false);
				return;
			}
			bool didCallCorpseBegin;
			GameObject corpseObj;
			if (Object.op_Implicit((Object)(object)get_enemyDeathEffects(instance2)))
			{
				get_enemyDeathEffects(instance2).SkipKillFreeze = true;
				get_enemyDeathEffects(instance2).ReceiveBeGoneEvent(attackDirection, attackType, nailElement, damageSource, corpseFlingMultiplier, instance2.deathReset, action, out didCallCorpseBegin, out corpseObj);
			}
			else
			{
				didCallCorpseBegin = false;
				corpseObj = null;
			}
			Utils.Logger.Debug((object)$"didCallCorpseBegin: {didCallCorpseBegin} {corpseObj} {((corpseObj != null) ? GameObjectExtensions.FullName(corpseObj) : null)} {action}");
			ActiveCorpse val3 = default(ActiveCorpse);
			if (Configs.Mode == NoEnemiesMode.BeGone && Object.op_Implicit((Object)(object)corpseObj) && corpseObj.TryGetComponent<ActiveCorpse>(ref val3))
			{
				Utils.Logger.Debug((object)$"corpseObj change color: {corpseObj} {GameObjectExtensions.FullName(corpseObj)}");
				Color color = ((tk2dBaseSprite)ActiveCorpseExtensions.get_sprite(val3)).color;
				color.a = 0f;
				((tk2dBaseSprite)ActiveCorpseExtensions.get_sprite(val3)).color = color;
				val3.SetBlockAudio(true);
			}
			if (!didCallCorpseBegin)
			{
				action?.Invoke(Object.op_Implicit((Object)(object)corpseObj) ? corpseObj.transform : ((Component)instance2).transform);
			}
			if (Object.op_Implicit((Object)(object)corpseObj) && Object.op_Implicit((Object)(object)get_corpseEventResponder(instance2)))
			{
				corpseObj.GetComponent<EventRelay>().TemporaryEvent += get_corpseEventResponder(instance2).ReceiveEvent;
				Utils.Logger.Debug((object)$"corpseObj: {corpseObj} {GameObjectExtensions.FullName(corpseObj)}");
			}
		}

		[SpecialName]
		public static List<HealthManagerItemDropGroupProxy> get_itemDropGroups(HealthManager instance)
		{
			IList fieldValue = ObjectExtensions.GetFieldValue<IList>((object)instance, "itemDropGroups");
			if (fieldValue != null)
			{
				return (from x in fieldValue.OfType<object>()
					select new HealthManagerItemDropGroupProxy(x)).ToList();
			}
			return new List<HealthManagerItemDropGroupProxy>();
		}

		[SpecialName]
		public static void set_itemDropGroups(HealthManager instance, List<HealthManagerItemDropGroupProxy> value)
		{
			ObjectExtensions.SetFieldValue<List<object>>((object)instance, "itemDropGroups", value.Select((HealthManagerItemDropGroupProxy x) => ((ClassProxy)x).Native).ToList());
		}

		[SpecialName]
		public static bool get_hasBlackThreadState(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "hasBlackThreadState");
		}

		[SpecialName]
		public static void set_hasBlackThreadState(HealthManager instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "hasBlackThreadState", value);
		}

		[SpecialName]
		public static BlackThreadState get_blackThreadState(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<BlackThreadState>((object)instance, "blackThreadState");
		}

		[SpecialName]
		public static void set_blackThreadState(HealthManager instance, BlackThreadState value)
		{
			ObjectExtensions.SetFieldValue<BlackThreadState>((object)instance, "blackThreadState", value);
		}

		[SpecialName]
		public static GameObject get_battleScene(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<GameObject>((object)instance, "battleScene");
		}

		[SpecialName]
		public static void set_battleScene(HealthManager instance, GameObject value)
		{
			ObjectExtensions.SetFieldValue<GameObject>((object)instance, "battleScene", value);
		}

		[SpecialName]
		public static bool get_bigEnemyDeath(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "bigEnemyDeath");
		}

		[SpecialName]
		public static void set_bigEnemyDeath(HealthManager instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "bigEnemyDeath", value);
		}

		[SpecialName]
		public static bool get_preventDeathAfterHero(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "preventDeathAfterHero");
		}

		[SpecialName]
		public static void set_preventDeathAfterHero(HealthManager instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "preventDeathAfterHero", value);
		}

		[SpecialName]
		public static int get_shellShardDrops(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<int>((object)instance, "shellShardDrops");
		}

		[SpecialName]
		public static void set_shellShardDrops(HealthManager instance, int value)
		{
			ObjectExtensions.SetFieldValue<int>((object)instance, "shellShardDrops", value);
		}

		[SpecialName]
		public static int get_smallGeoDrops(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<int>((object)instance, "smallGeoDrops");
		}

		[SpecialName]
		public static void set_smallGeoDrops(HealthManager instance, int value)
		{
			ObjectExtensions.SetFieldValue<int>((object)instance, "smallGeoDrops", value);
		}

		[SpecialName]
		public static int get_mediumGeoDrops(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<int>((object)instance, "mediumGeoDrops");
		}

		[SpecialName]
		public static void set_mediumGeoDrops(HealthManager instance, int value)
		{
			ObjectExtensions.SetFieldValue<int>((object)instance, "mediumGeoDrops", value);
		}

		[SpecialName]
		public static int get_largeGeoDrops(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<int>((object)instance, "largeGeoDrops");
		}

		[SpecialName]
		public static void set_largeGeoDrops(HealthManager instance, int value)
		{
			ObjectExtensions.SetFieldValue<int>((object)instance, "largeGeoDrops", value);
		}

		[SpecialName]
		public static int get_largeSmoothGeoDrops(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<int>((object)instance, "largeSmoothGeoDrops");
		}

		[SpecialName]
		public static void set_largeSmoothGeoDrops(HealthManager instance, int value)
		{
			ObjectExtensions.SetFieldValue<int>((object)instance, "largeSmoothGeoDrops", value);
		}

		[SpecialName]
		public static float[] get__shellShardMultiplierArray(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<float[]>((object)instance, "_shellShardMultiplierArray");
		}

		[SpecialName]
		public static void set__shellShardMultiplierArray(HealthManager instance, float[] value)
		{
			ObjectExtensions.SetFieldValue<float[]>((object)instance, "_shellShardMultiplierArray", value);
		}

		[SpecialName]
		public static bool get_megaFlingGeo(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "megaFlingGeo");
		}

		[SpecialName]
		public static void set_megaFlingGeo(HealthManager instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "megaFlingGeo", value);
		}

		[SpecialName]
		public static QueuedDropItem get_queuedDropItem(HealthManager instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ObjectExtensions.GetFieldValue<QueuedDropItem>((object)instance, "queuedDropItem");
		}

		[SpecialName]
		public static void set_queuedDropItem(HealthManager instance, QueuedDropItem value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ObjectExtensions.SetFieldValue<QueuedDropItem>((object)instance, "queuedDropItem", value);
		}

		[SpecialName]
		public static GameObject get_zeroHPEventOverride(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<GameObject>((object)instance, "zeroHPEventOverride");
		}

		[SpecialName]
		public static void set_zeroHPEventOverride(HealthManager instance, GameObject value)
		{
			ObjectExtensions.SetFieldValue<GameObject>((object)instance, "zeroHPEventOverride", value);
		}

		[SpecialName]
		public static DamageHero get_damageHero(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<DamageHero>((object)instance, "damageHero");
		}

		[SpecialName]
		public static void set_damageHero(HealthManager instance, DamageHero value)
		{
			ObjectExtensions.SetFieldValue<DamageHero>((object)instance, "damageHero", value);
		}

		[SpecialName]
		public static bool get_notifiedBattleScene(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "notifiedBattleScene");
		}

		[SpecialName]
		public static void set_notifiedBattleScene(HealthManager instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "notifiedBattleScene", value);
		}

		[SpecialName]
		public static AudioMixerSnapshot get_deathAudioSnapshot(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<AudioMixerSnapshot>((object)instance, "deathAudioSnapshot");
		}

		[SpecialName]
		public static void set_deathAudioSnapshot(HealthManager instance, AudioMixerSnapshot value)
		{
			ObjectExtensions.SetFieldValue<AudioMixerSnapshot>((object)instance, "deathAudioSnapshot", value);
		}

		[SpecialName]
		public static GameObject get_sendKilledTo(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<GameObject>((object)instance, "sendKilledTo");
		}

		[SpecialName]
		public static void set_sendKilledTo(HealthManager instance, GameObject value)
		{
			ObjectExtensions.SetFieldValue<GameObject>((object)instance, "sendKilledTo", value);
		}

		[SpecialName]
		public static GameObject get_corpseSplatPrefab(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<GameObject>((object)instance, "corpseSplatPrefab");
		}

		[SpecialName]
		public static void set_corpseSplatPrefab(HealthManager instance, GameObject value)
		{
			ObjectExtensions.SetFieldValue<GameObject>((object)instance, "corpseSplatPrefab", value);
		}

		[SpecialName]
		public static Vector3 get_effectOrigin(HealthManager instance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ObjectExtensions.GetFieldValue<Vector3>((object)instance, "effectOrigin");
		}

		[SpecialName]
		public static void set_effectOrigin(HealthManager instance, Vector3 value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ObjectExtensions.SetFieldValue<Vector3>((object)instance, "effectOrigin", value);
		}

		[SpecialName]
		public static EnemyDeathEffects get_enemyDeathEffects(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<EnemyDeathEffects>((object)instance, "enemyDeathEffects");
		}

		[SpecialName]
		public static void set_enemyDeathEffects(HealthManager instance, EnemyDeathEffects value)
		{
			ObjectExtensions.SetFieldValue<EnemyDeathEffects>((object)instance, "enemyDeathEffects", value);
		}

		[SpecialName]
		public static EventRelayResponder get_corpseEventResponder(HealthManager instance)
		{
			return ObjectExtensions.GetFieldValue<EventRelayResponder>((object)instance, "corpseEventResponder");
		}

		[SpecialName]
		public static void set_corpseEventResponder(HealthManager instance, EventRelayResponder value)
		{
			ObjectExtensions.SetFieldValue<EventRelayResponder>((object)instance, "corpseEventResponder", value);
		}

		[SpecialName]
		public static void Invincible(this HealthManager instance, HitInstance hitInstance1)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ObjectExtensions.MethodInvoke((object)instance, "Invincible", new object[1] { hitInstance1 });
		}

		[SpecialName]
		public static void TakeDamage(this HealthManager instance, HitInstance hitInstance1)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ObjectExtensions.MethodInvoke((object)instance, "TakeDamage", new object[1] { hitInstance1 });
		}

		[SpecialName]
		public static void DieDropFling(this HealthManager instance, ToolDamageFlags toolDamageFlags1, bool bool1)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ObjectExtensions.MethodInvoke((object)instance, "DieDropFling", new object[2] { toolDamageFlags1, bool1 });
		}

		[SpecialName]
		public static void SpawnCurrency(this HealthManager instance, Transform transform1, float float1, float float2, float float3, float float4, int int1, int int2, int int3, int int4, bool bool1, int int5, bool bool2)
		{
			ObjectExtensions.MethodInvoke((object)instance, "SpawnCurrency", new object[12]
			{
				transform1, float1, float2, float3, float4, int1, int2, int3, int4, bool1,
				int5, bool2
			});
		}

		[SpecialName]
		public static void SpawnQueuedItemDrop(this HealthManager instance, QueuedDropItem healthManager_QueuedDropItem1, Transform transform1)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ObjectExtensions.MethodInvoke((object)instance, "SpawnQueuedItemDrop", new object[2] { healthManager_QueuedDropItem1, transform1 });
		}

		[SpecialName]
		public static void SpawnItemDrop(this HealthManager instance, SavedItem savedItem1, int int1, CollectableItemPickup collectableItemPickup1, Transform transform1, int int2)
		{
			ObjectExtensions.MethodInvoke((object)instance, "SpawnItemDrop", new object[5] { savedItem1, int1, collectableItemPickup1, transform1, int2 });
		}

		[SpecialName]
		public static void NonFatalHit(this HealthManager instance, bool bool1)
		{
			ObjectExtensions.MethodInvoke((object)instance, "NonFatalHit", new object[1] { bool1 });
		}
	}
	[AccessExtensions]
	[AccessInstance<HeroController>]
	[AccessMethod("SetState", new Type[] { typeof(ActorStates) })]
	public static class HeroControllerExtensions
	{
		public sealed class <>E__0
		{
			public void SetState(ActorStates actorStates1)
			{
				throw null;
			}
		}

		[SpecialName]
		public static void SetState(this HeroController instance, ActorStates actorStates1)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ObjectExtensions.MethodInvoke((object)instance, "SetState", new object[1] { actorStates1 });
		}
	}
}
namespace HKSS.NoEnemies.Behaviour
{
	public class NoEnemiesController : MonoBehaviour
	{
		internal static HitInstance HitInstance = new HitInstance
		{
			AttackType = (AttackTypes)1,
			CircleDirection = false,
			DamageDealt = 9999,
			Direction = 0f,
			IgnoreInvulnerable = true,
			Multiplier = 1f
		};

		internal HealthManager? HealthManager;

		private void Start()
		{
			HitInstance.Source = ((Component)HeroController.instance).gameObject;
			Utils.Logger.Debug((object)$"Enemy {((Object)((Component)this).gameObject).name} hp {HealthManager?.hp}");
			EnemyHandle();
		}

		private void EnemyHandle()
		{
			if (Configs.Mode != 0 && Configs.Mode == NoEnemiesMode.BeGone)
			{
				EnemyBeGone();
			}
		}

		private void EnemyBeGone()
		{
			//IL_003d: 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)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			Utils.Logger.Info((object)("Enemy " + ((Object)((Component)this).gameObject).name + " be gone"));
			if (Object.op_Implicit((Object)(object)HealthManager))
			{
				HealthManager.DieDropFling(HitInstance.ToolDamageFlags, bool1: true);
				HealthManager.BeGone(null, HitInstance.AttackType, HitInstance.NailElement, HitInstance.Source, HitInstance.IgnoreInvulnerable, 0f);
			}
		}
	}
}