using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace SuperHardKnuckle;

internal static class Buddy
{
	public const string GivenFlag = "skmod_run_buddy_given";

	public const string OldSavedFlag = "skmod_buddy_given";

	[ThreadStatic]
	public static bool Granting;

	public static float Left = -1f;

	private static readonly HashSet<string> names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private static float runTime;

	private static bool granted;

	private static bool gaveUp;

	private static int attempts;

	private static float verifyAt = -1f;

	private static Trinket trinket;

	public static void Reset()
	{
		Left = -1f;
		runTime = 0f;
		granted = false;
		gaveUp = false;
		names.Clear();
		attempts = 0;
		verifyAt = -1f;
		trinket = null;
	}

	public static void Tick()
	{
		if (!Cfg.BuddyEnabled.Value)
		{
			Left = -1f;
			return;
		}
		ENT_Player val = Util.Player();
		if ((Object)(object)val == (Object)null || ((GameEntity)val).dead || CL_GameManager.isDead() || (Object)(object)Inventory.instance == (Object)null || ((Object)(object)CL_GameManager.gMan != (Object)null && CL_GameManager.gMan.isPaused))
		{
			return;
		}
		runTime += Time.deltaTime;
		if (!granted && !gaveUp && runTime > 2f)
		{
			Grant();
		}
		if (!granted)
		{
			return;
		}
		if (verifyAt > 0f && runTime >= verifyAt)
		{
			if (HasBuddyInInventory())
			{
				verifyAt = -1f;
				Util.Debug("Calming Buddy is in the inventory.");
			}
			else if (attempts < 3 && (Object)(object)trinket != (Object)null)
			{
				attempts++;
				Util.Debug("Calming Buddy missing from inventory, giving it again (try " + attempts + ").");
				Granting = true;
				try
				{
					trinket.Activate(0f);
				}
				catch (Exception ex)
				{
					Util.LogOnce("buddyretry", "Retry failed: " + ex.Message);
				}
				finally
				{
					Granting = false;
				}
				verifyAt = runTime + 3f;
			}
			else
			{
				verifyAt = -1f;
				Util.LogOnce("buddygone", "Calming Buddy never showed up in the inventory.");
			}
		}
		if (Left < 0f)
		{
			Left = Cfg.BuddyPetSeconds.Value;
		}
		Left -= Time.deltaTime;
		if (!(Left <= 0f))
		{
			return;
		}
		Left = Cfg.BuddyPetSeconds.Value;
		Util.Debug("You forgot to pet your Calming Buddy.");
		try
		{
			((GameEntity)val).Kill("calmingbuddy", DamageInfo.CreateDamageInfo(99999f, "calmingbuddy"));
		}
		catch (Exception ex2)
		{
			Util.LogOnce("buddykill", "Buddy kill failed: " + ex2.Message);
		}
	}

	private static void Grant()
	{
		Trinket val = FindTrinket();
		if ((Object)(object)val == (Object)null)
		{
			gaveUp = true;
			Util.LogOnce("nobuddy", "Calming Buddy trinket not found - the buddy rule is off this run.");
			return;
		}
		if (val.itemsToGrant != null)
		{
			foreach (Item_Object item in val.itemsToGrant)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				names.Add(Util.Clean(((Object)item).name));
				if (item.itemData != null)
				{
					if (!string.IsNullOrEmpty(item.itemData.prefabName))
					{
						names.Add(item.itemData.prefabName);
					}
					if (!string.IsNullOrEmpty(item.itemData.itemName))
					{
						names.Add(item.itemData.itemName);
					}
				}
			}
		}
		if (names.Count == 0)
		{
			gaveUp = true;
			Util.LogOnce("buddynoitem", "Calming Buddy trinket '" + ((Object)val).name + "' has no item to pet - the buddy rule is off this run.");
			return;
		}
		bool flag = HasBuddyInInventory();
		if (!flag)
		{
			try
			{
				flag = CL_GameManager.HasActiveFlag("skmod_run_buddy_given", false);
			}
			catch
			{
			}
		}
		if (!flag)
		{
			Granting = true;
			try
			{
				val.Activate(0f);
			}
			catch (Exception ex)
			{
				Util.LogOnce("buddygrant", "Giving the Calming Buddy failed: " + ex.Message);
				gaveUp = true;
				return;
			}
			finally
			{
				Granting = false;
			}
			try
			{
				CL_GameManager.SetGameFlag("skmod_run_buddy_given", true, "", false, false);
			}
			catch
			{
			}
			if (!HasBuddyInInventory())
			{
				Util.Debug("Calming Buddy trinket ran but no buddy item showed up in the inventory yet.");
			}
		}
		granted = true;
		trinket = val;
		verifyAt = runTime + 3f;
		Left = Cfg.BuddyPetSeconds.Value;
		Util.Debug("Calming Buddy given (" + ((Object)val).name + "): " + string.Join(", ", new List<string>(names).ToArray()));
	}

	private static Trinket FindTrinket()
	{
		WKAssetDatabase val = Util.Db();
		List<Trinket> list = new List<Trinket>();
		if ((Object)(object)val != (Object)null && val.trinketAssets != null)
		{
			list.AddRange(val.trinketAssets);
		}
		M_Gamemode currentGamemode = CL_GameManager.GetCurrentGamemode();
		if ((Object)(object)currentGamemode != (Object)null && (Object)(object)currentGamemode.availableTrinkets != (Object)null && currentGamemode.availableTrinkets.trinkets != null)
		{
			list.AddRange(currentGamemode.availableTrinkets.trinkets);
		}
		foreach (Trinket item in list)
		{
			if (!((Object)(object)item == (Object)null) && !item.isBinding)
			{
				string text = (((Object)item).name + " " + item.title).ToLowerInvariant().Replace(" ", "");
				if (text.Contains("calmingbuddy") || (text.Contains("calm") && text.Contains("buddy")))
				{
					return item;
				}
			}
		}
		foreach (Trinket item2 in list)
		{
			if (!((Object)(object)item2 == (Object)null) && !item2.isBinding && (((Object)item2).name + " " + item2.title).ToLowerInvariant().Contains("buddy"))
			{
				return item2;
			}
		}
		return null;
	}

	private static bool HasBuddyInInventory()
	{
		try
		{
			Inventory instance = Inventory.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			foreach (Item item in instance.GetItems(true, true, true))
			{
				if (IsBuddy(item))
				{
					return true;
				}
			}
		}
		catch
		{
		}
		return false;
	}

	public static bool IsBuddy(Item item)
	{
		if (item == null || names.Count == 0)
		{
			return false;
		}
		if (item.prefabName == null || !names.Contains(item.prefabName))
		{
			if (item.itemName != null)
			{
				return names.Contains(item.itemName);
			}
			return false;
		}
		return true;
	}

	public static void OnUse(Item item)
	{
		if (granted && IsBuddy(item))
		{
			Left = Cfg.BuddyPetSeconds.Value;
			Util.Debug("Petted the Calming Buddy.");
		}
	}
}
internal static class RedRoaches
{
	private static float timer;

	private static readonly List<GameObject> spawned = new List<GameObject>();

	public static void Reset()
	{
		timer = 0f;
		spawned.Clear();
	}

	public unsafe static void Tick()
	{
		//IL_0110: 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_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_013e: Unknown result type (might be due to invalid IL or missing references)
		if (Cfg.RedRoachSpawnSeconds.Value <= 0f || Zones.Current == Zone.None)
		{
			return;
		}
		ENT_Player val = Util.Player();
		if ((Object)(object)val == (Object)null || ((GameEntity)val).dead || CL_GameManager.isDead() || ((Object)(object)CL_GameManager.gMan != (Object)null && CL_GameManager.gMan.isPaused) || ((Object)(object)CL_EventManager.currentLevel != (Object)null && CL_EventManager.currentLevel.safeArea))
		{
			return;
		}
		timer += Time.deltaTime;
		if (timer < Cfg.RedRoachSpawnSeconds.Value)
		{
			return;
		}
		timer = 0f;
		spawned.RemoveAll((GameObject g) => (Object)(object)g == (Object)null || !g.activeInHierarchy);
		if (spawned.Count >= Cfg.RedRoachMax.Value)
		{
			return;
		}
		GameObject val2 = Util.FindPrefabNamed("roach_explosive");
		if (!((Object)(object)val2 == (Object)null) && Util.SpotAroundPlayer(8f, 18f, out var pos))
		{
			Transform parent = null;
			try
			{
				parent = WorldLoader.GetCurrentLevelParentRoot();
			}
			catch
			{
			}
			GameObject val3 = Util.Spawn(val2, pos + Vector3.up * 0.3f, Quaternion.Euler(0f, Random.Range(0f, 360f), 0f), parent);
			if ((Object)(object)val3 != (Object)null)
			{
				spawned.Add(val3);
				EntityRules.MarkSpawned(val3);
				Util.Debug("Red roach spawned at " + ((object)(*(Vector3*)(&pos))/*cast due to .constrained prefix*/).ToString());
			}
		}
	}
}
internal static class SilosSturges
{
	private static float timer;

	private static readonly List<GameObject> spawned = new List<GameObject>();

	public static void Reset()
	{
		timer = 0f;
		spawned.Clear();
	}

	public unsafe static void Tick()
	{
		//IL_00f7: 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)
		//IL_0107: 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)
		if (Zones.Current != Zone.Silos || Cfg.SilosSturgeInterval.Value <= 0f)
		{
			return;
		}
		ENT_Player val = Util.Player();
		if ((Object)(object)val == (Object)null || ((GameEntity)val).dead || CL_GameManager.isDead() || ((Object)(object)CL_GameManager.gMan != (Object)null && CL_GameManager.gMan.isPaused))
		{
			return;
		}
		timer += Time.deltaTime;
		if (timer < Cfg.SilosSturgeInterval.Value)
		{
			return;
		}
		timer = 0f;
		spawned.RemoveAll((GameObject g) => (Object)(object)g == (Object)null || !g.activeInHierarchy);
		if (spawned.Count >= Cfg.SilosSturgeMax.Value)
		{
			return;
		}
		GameObject val2 = Util.FindPrefabNamed("sturge");
		if (!((Object)(object)val2 == (Object)null) && Util.SpotAroundPlayer(12f, 22f, out var pos))
		{
			Transform parent = null;
			try
			{
				parent = WorldLoader.GetCurrentLevelParentRoot();
			}
			catch
			{
			}
			GameObject val3 = Util.Spawn(val2, pos + Vector3.up * 2.5f, Quaternion.Euler(0f, Random.Range(0f, 360f), 0f), parent);
			if ((Object)(object)val3 != (Object)null)
			{
				spawned.Add(val3);
				EntityRules.MarkSpawned(val3);
				Util.Debug("Sturge spawned in the Silos at " + ((object)(*(Vector3*)(&pos))/*cast due to .constrained prefix*/).ToString());
			}
		}
	}
}
internal static class CavityRoute
{
	public const string Flag = "skmod_run_cavity_done";

	public const string OldSavedFlag = "skmod_cavity_done";

	private static bool doneLocal;

	private static M_Level lastLevel;

	private static M_Level levelBeforeCavity;

	private static bool inCavity;

	private static bool ratKingSeen;

	private static bool ratKingDealt;

	private static bool hasBreakRoom;

	private static Vector3 breakRoomPos;

	private static M_Level breakRoomLevel;

	private static bool hasOutside;

	private static Vector3 lastOutsidePos;

	private static readonly Queue<Vector3> history = new Queue<Vector3>();

	private static float blockCooldown;

	private static float nextTick;

	public static bool Done
	{
		get
		{
			if (doneLocal)
			{
				return true;
			}
			try
			{
				return CL_GameManager.HasActiveFlag("skmod_run_cavity_done", false);
			}
			catch
			{
				return false;
			}
		}
	}

	public static void Reset()
	{
		doneLocal = false;
		lastLevel = null;
		levelBeforeCavity = null;
		inCavity = false;
		ratKingSeen = (ratKingDealt = false);
		hasBreakRoom = false;
		breakRoomLevel = null;
		hasOutside = false;
		blockCooldown = 0f;
		history.Clear();
	}

	private static bool HasAny(string text, string csv)
	{
		string[] array = csv.Split(',');
		for (int i = 0; i < array.Length; i++)
		{
			string text2 = array[i].Trim().ToLowerInvariant();
			if (text2.Length > 0 && text.Contains(text2))
			{
				return true;
			}
		}
		return false;
	}

	public static void Tick()
	{
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_030e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0302: Unknown result type (might be due to invalid IL or missing references)
		//IL_0325: Unknown result type (might be due to invalid IL or missing references)
		//IL_0338: 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_0347: Unknown result type (might be due to invalid IL or missing references)
		//IL_034c: Unknown result type (might be due to invalid IL or missing references)
		//IL_035d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0362: Unknown result type (might be due to invalid IL or missing references)
		if (!Cfg.CavityRoute.Value)
		{
			return;
		}
		ENT_Player val = Util.Player();
		if ((Object)(object)val == (Object)null || ((GameEntity)val).dead || CL_GameManager.isDead())
		{
			return;
		}
		M_Level currentLevel = CL_EventManager.currentLevel;
		M_Subregion currentSubregion = CL_EventManager.currentSubregion;
		bool flag = ((((Object)(object)currentLevel != (Object)null) ? (currentLevel.levelName + " " + ((Object)currentLevel).name) : "") + " " + (((Object)(object)currentSubregion != (Object)null) ? (currentSubregion.subregionName + " " + ((Object)currentSubregion).name) : "")).ToLowerInvariant().Contains("cavity");
		bool flag2 = IsServiceShaft(currentLevel, currentSubregion);
		bool flag3 = false;
		try
		{
			flag3 = val.IsGrounded(false);
		}
		catch
		{
		}
		if (Zones.Current == Zone.Habitation && (Object)(object)currentLevel != (Object)null && currentLevel.safeArea && !flag && !flag2 && flag3)
		{
			hasBreakRoom = true;
			breakRoomPos = ((Component)val).transform.position;
			breakRoomLevel = currentLevel;
		}
		if (!flag2 && !flag && flag3 && Time.unscaledTime >= nextTick)
		{
			nextTick = Time.unscaledTime + 0.5f;
			history.Enqueue(((Component)val).transform.position);
			while (history.Count > 10)
			{
				history.Dequeue();
			}
			hasOutside = true;
			lastOutsidePos = history.Peek();
		}
		if (inCavity)
		{
			List<DEN_RatKing> activeRatKings = DEN_RatKing.activeRatKings;
			bool flag4 = false;
			if (activeRatKings != null)
			{
				foreach (DEN_RatKing item in activeRatKings)
				{
					if ((Object)(object)item != (Object)null && !((GameEntity)item).dead && ((Component)item).gameObject.activeInHierarchy)
					{
						flag4 = true;
						ratKingSeen = true;
					}
				}
			}
			if (ratKingSeen && !flag4 && !ratKingDealt)
			{
				ratKingDealt = true;
				Util.Debug("Body cavity: Rat King dealt with.");
			}
		}
		if ((Object)(object)currentLevel != (Object)(object)lastLevel)
		{
			M_Level val2 = lastLevel;
			lastLevel = currentLevel;
			if (flag && !inCavity)
			{
				inCavity = true;
				levelBeforeCavity = val2;
				ratKingSeen = (ratKingDealt = false);
				Util.Debug("Entered the body cavity from " + (((Object)(object)val2 != (Object)null) ? val2.levelName : "?"));
			}
			else if (!flag && inCavity)
			{
				inCavity = false;
				bool flag5 = (Object)(object)currentLevel != (Object)(object)levelBeforeCavity;
				if ((flag5 || ratKingDealt) && !Done)
				{
					Complete(flag5 ? "reached the end of the body cavity" : "came back after dealing with the Rat King");
				}
				else
				{
					Util.Debug("Left the body cavity without finishing it.");
				}
			}
		}
		if (flag2 && !Done && Time.unscaledTime >= blockCooldown)
		{
			blockCooldown = Time.unscaledTime + 1.5f;
			Vector3? val3 = (hasOutside ? new Vector3?(lastOutsidePos) : (hasBreakRoom ? new Vector3?(breakRoomPos) : ((Vector3?)null)));
			if (val3.HasValue && GroundBelow(val3.Value))
			{
				CL_GameManager.gMan.TeleportPlayer(val3.Value + Vector3.up * 0.2f);
				Util.Debug("Security Shaft is sealed - pushed back to " + ((object)val3.Value/*cast due to .constrained prefix*/).ToString());
			}
			Hud.Flash("SECURITY GATE SEALED - beat the Body Cavity first");
		}
	}

	public static void OnChamberLeft()
	{
		if (Cfg.CavityRoute.Value && inCavity && !Done)
		{
			Complete("left the body cavity chamber");
		}
	}

	private static void Complete(string why)
	{
		//IL_007b: 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_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		doneLocal = true;
		try
		{
			CL_GameManager.SetGameFlag("skmod_run_cavity_done", true, "", false, false);
		}
		catch (Exception ex)
		{
			Util.LogOnce("cavflag", "Could not save the body cavity flag: " + ex.Message);
		}
		Util.Debug("Body cavity beaten (" + why + "). Security Shaft unlocked.");
		Hud.Flash("BODY CAVITY BEATEN - the security gate opens");
		if (hasBreakRoom && (Object)(object)breakRoomLevel != (Object)null && ((Component)breakRoomLevel).gameObject.activeInHierarchy && GroundBelow(breakRoomPos))
		{
			CL_GameManager.gMan.TeleportPlayer(breakRoomPos + Vector3.up * 0.2f);
			Util.Debug("Teleported back to the break room (" + breakRoomLevel.levelName + ").");
		}
		else
		{
			Util.Debug("Break room isn't loaded any more, so no teleport back.");
		}
	}

	private static bool IsServiceShaft(M_Level lv, M_Subregion sr)
	{
		string text = (((Object)(object)lv != (Object)null) ? (lv.levelName + " " + ((Object)lv).name).ToLowerInvariant() : "");
		if (text.Contains("intro") || text.Contains("interlude") || text.Contains("cavity"))
		{
			return false;
		}
		if ((Object)(object)lv != (Object)null && lv.safeArea)
		{
			return false;
		}
		if (text.Length > 0 && HasAny(text, Cfg.ServiceShaftKeywords.Value))
		{
			return true;
		}
		string text2 = (((Object)(object)sr != (Object)null) ? (sr.subregionName + " " + ((Object)sr).name).ToLowerInvariant() : "");
		if (text.Length > 0 && (text2.Contains("service shaft") || text2.Contains("service_shaft")))
		{
			return !text2.Contains("ending");
		}
		return false;
	}

	public static void OnFlag(string name, bool state)
	{
		if (state && !string.IsNullOrEmpty(name) && Cfg.CavityRoute.Value && !Done)
		{
			string text = name.ToLowerInvariant();
			if (text.Contains("cavity") && !text.Contains("intro") && (text.Contains("complete") || text.Contains("finish") || text.Contains("beat") || text.Contains("end") || text.Contains("escape") || text.Contains("exit") || text.Contains("done") || text.Contains("win")))
			{
				Complete("game flag " + name);
			}
		}
	}

	private static bool GroundBelow(Vector3 pos)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		return Physics.Raycast(pos + Vector3.up * 1f, Vector3.down, 3f, -1, (QueryTriggerInteraction)1);
	}

	public static bool IsAmalgam(string name)
	{
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		return HasAny(name.ToLowerInvariant(), Cfg.AmalgamKeywords.Value);
	}
}
internal static class EntityRules
{
	private static readonly HashSet<int> seen = new HashSet<int>();

	private static readonly HashSet<int> clones = new HashSet<int>();

	private static float nextScan;

	private static float nextFaceCheck;

	private static int faceClonesThisVisit;

	private static Zone lastZone;

	private static int dronesThisZone;

	public static void Reset()
	{
		seen.Clear();
		clones.Clear();
		faceClonesThisVisit = 0;
		dronesThisZone = 0;
		lastZone = Zone.None;
		Util.ResetCaches();
	}

	public static bool IsClone(GameObject g)
	{
		if ((Object)(object)g != (Object)null)
		{
			return clones.Contains(((Object)g).GetInstanceID());
		}
		return false;
	}

	public static void Tick()
	{
		if (Zones.Current != lastZone)
		{
			lastZone = Zones.Current;
			faceClonesThisVisit = 0;
			dronesThisZone = 0;
		}
		if (Time.unscaledTime >= nextScan)
		{
			nextScan = Time.unscaledTime + 0.25f;
			Scan();
		}
		if (Zones.Current == Zone.Abyss && Time.unscaledTime >= nextFaceCheck)
		{
			nextFaceCheck = Time.unscaledTime + 1f;
			KeepFaces();
		}
	}

	private static void Scan()
	{
		List<GameEntity> entities = GameEntity.entities;
		if (entities == null)
		{
			return;
		}
		GameEntity[] array = entities.ToArray();
		foreach (GameEntity val in array)
		{
			if (!((Object)(object)val == (Object)null) && !(val is ENT_Player) && seen.Add(((Object)val).GetInstanceID()))
			{
				try
				{
					OnNewEntity(val);
				}
				catch (Exception ex)
				{
					Util.LogOnce("ent" + ((object)val).GetType().Name, "Rule for " + ((object)val).GetType().Name + " failed: " + ex.Message);
				}
			}
		}
	}

	private static void OnNewEntity(GameEntity e)
	{
		//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0309: Unknown result type (might be due to invalid IL or missing references)
		//IL_030e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0313: Unknown result type (might be due to invalid IL or missing references)
		//IL_0317: Unknown result type (might be due to invalid IL or missing references)
		//IL_0319: Unknown result type (might be due to invalid IL or missing references)
		Zone current = Zones.Current;
		string text = ((Object)((Component)e).gameObject).name.ToLowerInvariant();
		bool num = clones.Contains(((Object)((Component)e).gameObject).GetInstanceID());
		DEN_RatKing val = (DEN_RatKing)(object)((e is DEN_RatKing) ? e : null);
		if (val != null)
		{
			val.speed *= Cfg.RatKingSpeedMult.Value;
			Util.Debug("Rat King speed x" + Cfg.RatKingSpeedMult.Value);
		}
		DEN_Teeth val2 = (DEN_Teeth)(object)((e is DEN_Teeth) ? e : null);
		if (val2 != null && current == Zone.Habitation)
		{
			float value = Cfg.TeethSpeedMult.Value;
			val2.baseSpeed *= value;
			val2.chargeSpeed *= value;
			val2.walkSpeed *= value;
			val2.jumpSpeed *= value;
			Util.Debug("Teeth speed x" + value);
		}
		DEN_VentThing val3 = (DEN_VentThing)(object)((e is DEN_VentThing) ? e : null);
		if (val3 != null && current == Zone.Habitation)
		{
			float value2 = Cfg.VentThingSpeedMult.Value;
			val3.handSpeed *= value2;
			val3.pullForce *= value2;
			Util.Debug("Vent thing speed/pull x" + value2);
		}
		if (num || Util.HasGameEntityAncestor(e) || (Object)(object)((Component)e).GetComponent<Item_Object>() != (Object)null)
		{
			return;
		}
		bool flag = e is Denizen || e is AIGameEntity;
		int num2 = 0;
		string why = null;
		if (current == Zone.Silos && (e is DEN_Bloodbug || (flag && text.Contains("bloodbug"))))
		{
			num2 = Cfg.SilosBloodbugExtra.Value;
			why = "bloodbug";
		}
		else if (e is DEN_Barnacle || (flag && text.Contains("barnacle") && !text.Contains("zombie") && !text.Contains("tentacle")))
		{
			switch (current)
			{
			case Zone.Pipeworks:
				num2 = Cfg.PipeworksBarnacleExtra.Value;
				why = "barnacle";
				break;
			case Zone.Nest:
				num2 = Cfg.NestBarnacleExtra.Value;
				why = "barnacle";
				break;
			}
		}
		else if (current == Zone.Pipeworks && e is DEN_Hopper && !(e is DEN_Hopper_Tick))
		{
			num2 = Cfg.PipeworksHopperExtra.Value;
			why = "hopper roach";
		}
		if (e is DEN_Turret)
		{
			num2 = Cfg.TurretExtra.Value;
			why = "turret";
		}
		if (current == Zone.Silos && flag && text.Contains("sturge"))
		{
			num2 = Cfg.SilosSturgeExtra.Value;
			why = "sturge";
		}
		if (flag && SpawnRules.IsRedRoach(text))
		{
			num2 = Cfg.RedRoachExtra.Value;
			why = "red roach";
		}
		if (num2 > 0)
		{
			MakeCopies(e, num2, why);
		}
		if (current == Zone.Habitation && (e is DEN_Turret || e is DEN_GantryTurret) && dronesThisZone < 8 && Random.value < Cfg.TurretDroneChance.Value)
		{
			GameObject val4 = Util.FindPrefabWith<DEN_Drone>();
			if ((Object)(object)val4 != (Object)null)
			{
				Vector3 pos = ((Component)e).transform.position + Vector3.up * 2f + Random.insideUnitSphere * 1.5f;
				MarkClone(Util.Spawn(val4, pos, Quaternion.identity, ((Component)e).transform.parent));
				dronesThisZone++;
				Util.Debug("Drone spawned next to turret " + ((Object)((Component)e).gameObject).name);
			}
		}
	}

	private static void MakeCopies(GameEntity e, int count, string why)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: 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_001d: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < count; i++)
		{
			Vector3 val = Util.NearbySpot(((Component)e).transform);
			GameObject val2 = Object.Instantiate<GameObject>(((Component)e).gameObject, val, ((Component)e).transform.rotation, ((Component)e).transform.parent);
			((Object)val2).name = ((Object)((Component)e).gameObject).name;
			if (!val2.activeSelf)
			{
				val2.SetActive(true);
			}
			MarkClone(val2);
		}
		Util.Debug("+" + count + " " + why + " (" + ((Object)((Component)e).gameObject).name + ") in " + Zones.Current);
	}

	public static void MarkSpawned(GameObject g)
	{
		MarkClone(g);
	}

	private static void MarkClone(GameObject g)
	{
		if (!((Object)(object)g == (Object)null))
		{
			clones.Add(((Object)g).GetInstanceID());
			GameEntity[] componentsInChildren = g.GetComponentsInChildren<GameEntity>(true);
			foreach (GameEntity val in componentsInChildren)
			{
				seen.Add(((Object)val).GetInstanceID());
				clones.Add(((Object)((Component)val).gameObject).GetInstanceID());
			}
		}
	}

	private static void KeepFaces()
	{
		//IL_0086: 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_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		List<DEN_Face> faceInstances = DEN_Face.faceInstances;
		if (faceInstances == null)
		{
			return;
		}
		List<DEN_Face> list = faceInstances.Where((DEN_Face f) => (Object)(object)f != (Object)null && ((Component)f).gameObject.activeInHierarchy && !((GameEntity)f).dead).ToList();
		if (list.Count == 0 || list.Count >= Cfg.AbyssFaceCount.Value || faceClonesThisVisit >= Cfg.AbyssFaceCount.Value * 2)
		{
			return;
		}
		DEN_Face val = list[0];
		int num = Cfg.AbyssFaceCount.Value - list.Count;
		for (int num2 = 0; num2 < num; num2++)
		{
			Vector3 val2 = Random.insideUnitSphere * 12f;
			GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.position + val2, ((Component)val).transform.rotation, ((Component)val).transform.parent);
			((Object)val3).name = ((Object)((Component)val).gameObject).name;
			if (!val3.activeSelf)
			{
				val3.SetActive(true);
			}
			MarkClone(val3);
			faceClonesThisVisit++;
		}
		Util.Debug("Abyss: faces topped up to " + Cfg.AbyssFaceCount.Value);
	}
}
internal static class Hud
{
	private static GUIStyle style;

	private static GUIStyle big;

	private static string flash;

	private static float flashUntil;

	public static void Flash(string text)
	{
		flash = text;
		flashUntil = Time.unscaledTime + 4f;
	}

	public static void Draw()
	{
		//IL_00e0: 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_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Expected O, but got Unknown
		//IL_0080: 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_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Expected O, but got Unknown
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		if (Cfg.ShowHud.Value && Mode.IsActive() && (!((Object)(object)CL_GameManager.gMan != (Object)null) || !CL_GameManager.gMan.isPaused))
		{
			if (style == null)
			{
				style = new GUIStyle(GUI.skin.label)
				{
					fontSize = 14,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)1
				};
				style.normal.textColor = new Color(1f, 0.25f, 0.2f, 0.85f);
				big = new GUIStyle(style)
				{
					fontSize = 30
				};
				big.normal.textColor = new Color(1f, 0.15f, 0.1f, 1f);
			}
			float num = Screen.width;
			GUI.Label(new Rect(0f, 6f, num, 24f), "SUPER HARD", style);
			if (Timers.MotherLeft >= 0f)
			{
				GUI.Label(new Rect(0f, 34f, num, 40f), "MOTHER: " + Mathf.CeilToInt(Timers.MotherLeft) + "s", big);
			}
			if (flash != null && Time.unscaledTime < flashUntil)
			{
				GUI.Label(new Rect(0f, (float)Screen.height * 0.3f, num, 40f), flash, big);
			}
		}
	}
}
internal static class ItemRules
{
	private static readonly HashSet<int> seenItems = new HashSet<int>();

	private static readonly HashSet<int> seenVendors = new HashSet<int>();

	private static Dictionary<string, string> extraMap;

	private static readonly Regex tierRx = new Regex("_T([2-9])(?=$|_)", RegexOptions.Compiled);

	public static void Reset()
	{
		seenItems.Clear();
		seenVendors.Clear();
		extraMap = null;
	}

	public static void SlowTick()
	{
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
		Zone current = Zones.Current;
		ENT_Player val = Util.Player();
		Item_Object[] array = Object.FindObjectsByType<Item_Object>((FindObjectsInactive)0, (FindObjectsSortMode)0);
		foreach (Item_Object val2 in array)
		{
			if ((Object)(object)val2 == (Object)null || !seenItems.Add(((Object)val2).GetInstanceID()))
			{
				continue;
			}
			try
			{
				if ((val2.itemData != null && (val2.itemData.hasBeenPickedUp || val2.itemData.inBag)) || ((Object)(object)val != (Object)null && ((Component)val2).transform.IsChildOf(((Component)val).transform)) || (Object)(object)((Component)val2).GetComponentInParent<Inventory>() != (Object)null)
				{
					continue;
				}
				string text = ItemName(val2);
				if (Cfg.CavityRoute.Value && CavityRoute.IsAmalgam(text))
				{
					Util.Debug("No Amalgamator on Super Hard: removed " + text);
					Object.Destroy((Object)(object)((Component)val2).gameObject);
				}
				else if (current != Zone.Silos && current != Zone.Abyss)
				{
					seenItems.Remove(((Object)val2).GetInstanceID());
				}
				else if (current == Zone.Abyss && text.ToLowerInvariant().Contains("artifact"))
				{
					Util.Debug("Abyss: removed artifact " + text);
					Object.Destroy((Object)(object)((Component)val2).gameObject);
				}
				else
				{
					if (current != Zone.Silos)
					{
						continue;
					}
					string text2 = TierOne(text);
					if (text2 == null)
					{
						continue;
					}
					GameObject val3 = Util.ItemPrefab(text2);
					if ((Object)(object)val3 == (Object)null)
					{
						Util.DebugOnce("noT1" + text2, "Silos: wanted to swap " + text + " -> " + text2 + " but no such item.");
						continue;
					}
					GameObject val4 = Util.Spawn(val3, ((Component)val2).transform.position, ((Component)val2).transform.rotation, ((Component)val2).transform.parent);
					Item_Object val5 = (((Object)(object)val4 != (Object)null) ? val4.GetComponent<Item_Object>() : null);
					if ((Object)(object)val5 != (Object)null)
					{
						seenItems.Add(((Object)val5).GetInstanceID());
					}
					Util.Debug("Silos: swapped " + text + " -> " + text2);
					Object.Destroy((Object)(object)((Component)val2).gameObject);
					continue;
				}
			}
			catch (Exception ex)
			{
				Util.LogOnce("item" + ((Object)val2).name, "Item rule failed on " + ((Object)val2).name + ": " + ex.Message);
			}
		}
		if (current == Zone.Silos)
		{
			FixVendors();
		}
	}

	private static void FixVendors()
	{
		ENV_Vendor_Disk[] array = Object.FindObjectsByType<ENV_Vendor_Disk>((FindObjectsInactive)0, (FindObjectsSortMode)0);
		foreach (ENV_Vendor_Disk val in array)
		{
			if (!((Object)(object)val == (Object)null) && seenVendors.Add(((Object)val).GetInstanceID()) && !((Object)(object)val.purchaseObject == (Object)null))
			{
				Item_Object val2 = TierOneObject(val.purchaseObject);
				if ((Object)(object)val2 != (Object)null)
				{
					Util.Debug("Silos: disk vendor now sells " + ((Object)val2).name + " instead of " + ((Object)val.purchaseObject).name);
					val.purchaseObject = val2;
				}
			}
		}
		ENV_VendingMachine[] array2 = Object.FindObjectsByType<ENV_VendingMachine>((FindObjectsInactive)0, (FindObjectsSortMode)0);
		foreach (ENV_VendingMachine val3 in array2)
		{
			if ((Object)(object)val3 == (Object)null || !seenVendors.Add(((Object)val3).GetInstanceID()) || val3.purchaseList == null)
			{
				continue;
			}
			foreach (Purchase purchase in val3.purchaseList)
			{
				if (purchase != null && !((Object)(object)purchase.itemObject == (Object)null))
				{
					Item_Object val4 = TierOneObject(purchase.itemObject);
					if ((Object)(object)val4 != (Object)null)
					{
						Util.Debug("Silos: vending machine slot " + ((Object)purchase.itemObject).name + " -> " + ((Object)val4).name);
						purchase.itemObject = val4;
					}
				}
			}
		}
	}

	private static Item_Object TierOneObject(Item_Object io)
	{
		string text = TierOne(Util.Clean(((Object)io).name));
		if (text == null)
		{
			return null;
		}
		GameObject val = Util.ItemPrefab(text);
		if (!((Object)(object)val != (Object)null))
		{
			return null;
		}
		return val.GetComponent<Item_Object>();
	}

	private static string ItemName(Item_Object io)
	{
		string text = null;
		try
		{
			if (io.itemData != null)
			{
				text = io.itemData.prefabName;
			}
		}
		catch
		{
		}
		if (string.IsNullOrEmpty(text))
		{
			text = ((Object)((Component)io).gameObject).name;
		}
		return Util.Clean(text);
	}

	public static string TierOne(string name)
	{
		if (string.IsNullOrEmpty(name))
		{
			return null;
		}
		if (extraMap == null)
		{
			extraMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			string[] array = Cfg.TierOneMap.Value.Split(';', ',');
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split('=');
				if (array2.Length == 2 && array2[0].Trim().Length > 0 && array2[1].Trim().Length > 0)
				{
					extraMap[array2[0].Trim()] = array2[1].Trim();
				}
			}
		}
		if (extraMap.TryGetValue(name, out var value))
		{
			return value;
		}
		if (tierRx.IsMatch(name))
		{
			return tierRx.Replace(name, "_T1");
		}
		return null;
	}
}
internal static class Mode
{
	public const string SettingId = "skmod_super";

	public const string Title = "SUPER HARD";

	private static GamemodeSetting setting;

	internal static readonly HashSet<string> HardIds = new HashSet<string>();

	internal static readonly HashSet<string> SurvivalIds = new HashSet<string>();

	private static readonly HashSet<M_Gamemode> injected = new HashSet<M_Gamemode>();

	private static float nextMenuTick;

	private static int cacheFrame = -1;

	private static bool cacheValue;

	[ThreadStatic]
	internal static bool InCheck;

	private static bool leaderboardsTouched;

	private static bool leaderboardsBefore;

	private static readonly Dictionary<M_Subregion, KeyValuePair<float, bool>> cavityBackup = new Dictionary<M_Subregion, KeyValuePair<float, bool>>();

	internal static bool Broken;

	public static string Description => "Everything at once: +20% gravity, 3-second grip, no trinkets, weaker hammer, Remains every 10 minutes, 40% Engraved Doors, red roaches always, Hard Mode + Survival on. Every zone gets nastier.";

	public static GamemodeSetting Setting => setting;

	public static void MenuTick()
	{
		if (Time.unscaledTime < nextMenuTick)
		{
			return;
		}
		nextMenuTick = Time.unscaledTime + 1f;
		try
		{
			WKAssetDatabase val = Util.Db();
			if ((Object)(object)val != (Object)null && val.gamemodeAssets != null)
			{
				foreach (M_Gamemode gamemodeAsset in val.gamemodeAssets)
				{
					EnsureInjected(gamemodeAsset);
				}
			}
			EnsureInjected(CL_GameManager.GetCurrentGamemode());
		}
		catch (Exception ex)
		{
			Util.LogOnce("menutick", "Gamemode scan failed: " + ex.Message);
		}
	}

	public static void RemoveEverywhere()
	{
		foreach (M_Gamemode item in injected)
		{
			if ((Object)(object)item != (Object)null && item.gamemodeSettings != null)
			{
				item.gamemodeSettings.RemoveAll((GamemodeSetting x) => (Object)(object)x != (Object)null && x.id == "skmod_super");
			}
		}
	}

	public static void EnsureInjected(M_Gamemode mode)
	{
		if ((Object)(object)mode == (Object)null || mode.gamemodeSettings == null)
		{
			return;
		}
		List<GamemodeSetting> gamemodeSettings = mode.gamemodeSettings;
		if (Broken)
		{
			gamemodeSettings.RemoveAll((GamemodeSetting x) => (Object)(object)x != (Object)null && x.id == "skmod_super");
		}
		else
		{
			if (gamemodeSettings.Count == 0)
			{
				return;
			}
			GamemodeSetting val = null;
			GamemodeSetting val2 = null;
			GamemodeSetting val3 = null;
			foreach (GamemodeSetting item in gamemodeSettings)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item == (Object)(object)setting)
				{
					continue;
				}
				if ((Object)(object)val3 == (Object)null)
				{
					val3 = item;
				}
				string text = (item.id + " " + item.title + " " + ((Object)item).name).ToLowerInvariant();
				if (text.Contains("hard"))
				{
					HardIds.Add(item.id);
					if ((Object)(object)val == (Object)null)
					{
						val = item;
					}
				}
				if (text.Contains("iron") && (Object)(object)val2 == (Object)null)
				{
					val2 = item;
				}
				if (text.Contains("surviv"))
				{
					SurvivalIds.Add(item.id);
				}
			}
			if ((Object)(object)val == (Object)null && (Object)(object)val2 == (Object)null && !mode.allowHardmode)
			{
				return;
			}
			if (!gamemodeSettings.Any((GamemodeSetting s) => (Object)(object)s != (Object)null && s.id == "skmod_super"))
			{
				GamemodeSetting val4 = val ?? val2 ?? val3;
				if ((Object)(object)val4 == (Object)null)
				{
					return;
				}
				if ((Object)(object)setting == (Object)null)
				{
					setting = Create(val4);
				}
				gamemodeSettings.Add(setting);
			}
			if (injected.Add(mode))
			{
				Util.Debug("Added SUPER HARD to gamemode '" + mode.gamemodeName + "'. Its settings: " + string.Join(", ", (from s in gamemodeSettings
					where (Object)(object)s != (Object)null
					select s.id + " (" + s.title + ")").ToArray()));
				BlacklistTrinkets(mode);
			}
		}
	}

	private static GamemodeSetting Create(GamemodeSetting template)
	{
		//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)
		GamemodeSetting obj = Object.Instantiate<GamemodeSetting>(template);
		((Object)obj).name = "GamemodeSetting_SuperHard";
		((Object)obj).hideFlags = (HideFlags)32;
		obj.id = "skmod_super";
		obj.title = "SUPER HARD";
		obj.description = Description;
		obj.color = new Color(1f, 0.12f, 0.08f, 1f);
		obj.exclusiveSettings = new List<string>();
		obj.nameAppend = "Super Hard";
		obj.leaderboardAppendID = "superhardmod";
		obj.allowDownstream = false;
		obj.downstreamId = "";
		return obj;
	}

	private static void BlacklistTrinkets(M_Gamemode mode)
	{
		try
		{
			List<Trinket> list = new List<Trinket>();
			if ((Object)(object)mode.availableTrinkets != (Object)null && mode.availableTrinkets.trinkets != null)
			{
				list.AddRange(mode.availableTrinkets.trinkets);
			}
			WKAssetDatabase val = Util.Db();
			if ((Object)(object)val != (Object)null && val.trinketAssets != null)
			{
				list.AddRange(val.trinketAssets);
			}
			foreach (Trinket item in list)
			{
				if (!((Object)(object)item == (Object)null) && !item.isBinding)
				{
					if (item.settingBlacklist == null)
					{
						item.settingBlacklist = new List<string>();
					}
					if (!item.settingBlacklist.Contains("skmod_super"))
					{
						item.settingBlacklist.Add("skmod_super");
					}
				}
			}
		}
		catch (Exception ex)
		{
			Util.LogOnce("trinketbl", "Trinket blacklist failed: " + ex.Message);
		}
	}

	public static bool IsActive()
	{
		if (cacheFrame == Time.frameCount)
		{
			return cacheValue;
		}
		cacheFrame = Time.frameCount;
		cacheValue = false;
		try
		{
			if ((Object)(object)CL_GameManager.gMan == (Object)null)
			{
				return false;
			}
			cacheValue = IsOnFor(CL_GameManager.GetCurrentGamemode());
		}
		catch
		{
			cacheValue = false;
		}
		return cacheValue;
	}

	public static bool IsOnFor(M_Gamemode mode)
	{
		if ((Object)(object)mode == (Object)null)
		{
			return false;
		}
		if (InCheck)
		{
			return false;
		}
		InCheck = true;
		try
		{
			return mode.HasActiveSetting("skmod_super");
		}
		catch
		{
			return false;
		}
		finally
		{
			InCheck = false;
		}
	}

	public static void ApplyGlobalToggles(bool active)
	{
		try
		{
			if (active && Cfg.DisableLeaderboards.Value)
			{
				if (!leaderboardsTouched)
				{
					leaderboardsBefore = WK_Leaderboard_Core.disableLeaderboards;
					leaderboardsTouched = true;
				}
				WK_Leaderboard_Core.disableLeaderboards = true;
			}
			else if (leaderboardsTouched)
			{
				WK_Leaderboard_Core.disableLeaderboards = leaderboardsBefore;
				leaderboardsTouched = false;
			}
		}
		catch (Exception ex)
		{
			Util.LogOnce("lb", "Leaderboard toggle failed: " + ex.Message);
		}
		try
		{
			if (active)
			{
				if (cavityBackup.Count != 0)
				{
					return;
				}
				WKAssetDatabase val = Util.Db();
				if (!((Object)(object)val != (Object)null) || val.subRegionAssets == null)
				{
					return;
				}
				{
					foreach (M_Subregion subRegionAsset in val.subRegionAssets)
					{
						if (!((Object)(object)subRegionAsset == (Object)null) && (((Object)subRegionAsset).name + " " + subRegionAsset.subregionName).ToLowerInvariant().Contains("cavity"))
						{
							cavityBackup[subRegionAsset] = new KeyValuePair<float, bool>(subRegionAsset.chance, subRegionAsset.guaranteeIfNotVisited);
							subRegionAsset.chance = Mathf.Max(subRegionAsset.chance, 1f);
							subRegionAsset.guaranteeIfNotVisited = true;
							Util.Debug("Forcing body cavity route: " + ((Object)subRegionAsset).name);
						}
					}
					return;
				}
			}
			if (cavityBackup.Count <= 0)
			{
				return;
			}
			foreach (KeyValuePair<M_Subregion, KeyValuePair<float, bool>> item in cavityBackup)
			{
				if ((Object)(object)item.Key != (Object)null)
				{
					item.Key.chance = item.Value.Key;
					item.Key.guaranteeIfNotVisited = item.Value.Value;
				}
			}
			cavityBackup.Clear();
		}
		catch (Exception ex2)
		{
			Util.LogOnce("cavity", "Body cavity forcing failed: " + ex2.Message);
		}
	}
}
internal static class Patches
{
	private static int ok;

	private static int failed;

	[ThreadStatic]
	private static bool hopperHit;

	private static readonly FieldRef<DEN_Hopper_Tick, bool> tickAttached = Util.SafeFieldRef<DEN_Hopper_Tick, bool>("isAttached");

	private static readonly FieldRef<DEN_Hopper_Tick, float> tickDrained = Util.SafeFieldRef<DEN_Hopper_Tick, float>("currentBloodDrained");

	private static readonly FieldRef<DEN_Hopper_Tick, GameEntity> tickTarget = Util.SafeFieldRef<DEN_Hopper_Tick, GameEntity>("attachTarget");

	internal static bool MassPatched;

	public static void ApplyAll(Harmony h)
	{
		P(h, typeof(UI_GamemodeScreen_Panel), "FillSettings", null, "FillSettings_Pre");
		P(h, typeof(UI_GamemodeScreen), "Initialize", new Type[1] { typeof(M_Gamemode) }, "ScreenInit_Pre");
		P(h, typeof(UI_GamemodeSetting), "Initialize", new Type[2]
		{
			typeof(GamemodeSetting),
			typeof(UI_GamemodeScreen_Panel)
		}, null, null, "SettingInit_Finalizer");
		P(h, typeof(UI_GamemodeScreen_Panel), "FillSettings", null, null, null, "FillSettings_Finalizer");
		P(h, typeof(M_Gamemode), "HasActiveSetting", new Type[1] { typeof(string) }, null, "HasActiveSetting_Post");
		P(h, typeof(M_Gamemode), "GetActiveSettings", Type.EmptyTypes, null, "GetActiveSettings_Post");
		P(h, typeof(M_Gamemode), "IsHardMode", Type.EmptyTypes, null, "ModeIsHard_Post");
		P(h, typeof(CL_GameManager), "IsHardmode", Type.EmptyTypes, null, "GameIsHard_Post");
		P(h, typeof(Trinket), "Activate", null, "Trinket_Activate_Pre");
		P(h, typeof(HandItem), "TryUse", Type.EmptyTypes, "HandItemUse_Pre");
		P(h, typeof(HandItem_Buff_Grub), "Activate", Type.EmptyTypes, "HandItemUse_Pre");
		P(h, typeof(ENT_Player), "HandStamina", null, "HandStamina_Pre", "HandStamina_Post");
		P(h, typeof(ENT_Player), "Damage", new Type[1] { typeof(DamageInfo) }, "PlayerDamage_Pre", "PlayerDamage_Post");
		P(h, typeof(HandItem_Melee), "Hit", Type.EmptyTypes, "Melee_Pre", "Melee_Post");
		P(h, typeof(HandItem_Melee), "OnChargeAttackHit", null, "Melee_Pre", "Melee_Post");
		P(h, typeof(SpawnSettings), "RandomCheck", null, null, "RandomCheck_Post");
		P(h, typeof(UT_SpawnChance), "Check", Type.EmptyTypes, "SpawnChance_Pre");
		P(h, typeof(UT_EventChance), "Check", Type.EmptyTypes, "EventChance_Pre");
		P(h, typeof(UT_SpawnEntityByID), "Start", Type.EmptyTypes, "SpawnById_Pre");
		P(h, typeof(UT_SpawnEntityByID), "Spawn", Type.EmptyTypes, "SpawnById_Pre");
		P(h, typeof(SpawnTable), "GetRandomSpawnObject", Type.EmptyTypes, "SpawnTable_Pre");
		P(h, typeof(ENT_Player), "AddPerk", null, "AddPerk_Pre");
		P(h, typeof(UT_ChamberLoader), "LeaveChamber", Type.EmptyTypes, null, "LeaveChamber_Post");
		P(h, typeof(UT_BranchGenerator), "MovePlayerIntoBranch", Type.EmptyTypes, "Branch_Pre");
		P(h, typeof(CL_GameManager), "SetGameFlag", null, "SetGameFlag_Pre");
		P(h, typeof(CL_Button), "Interact", Type.EmptyTypes, null, "Button_Post");
		P(h, typeof(CL_Button), "Interact", new Type[1] { typeof(InteractionInfo) }, null, "Button_Post");
		P(h, typeof(CL_HoldButton), "Update", Type.EmptyTypes, null, "HoldButton_Post");
		P(h, typeof(DEN_Hopper_Tick), "Damage", new Type[1] { typeof(DamageInfo) }, "Tick_Damage_Pre");
		P(h, typeof(DEN_Hopper_Tick), "Detach", Type.EmptyTypes, "Tick_Detach_Pre");
		P(h, typeof(DEN_BasicDenizen), "Kill", new Type[2]
		{
			typeof(string),
			typeof(DamageInfo)
		}, "Tick_Kill_Pre");
		P(h, typeof(Denizen), "Kill", new Type[2]
		{
			typeof(string),
			typeof(DamageInfo)
		}, "Tick_Kill_Pre");
		P(h, typeof(DEN_Teeth), "Despawn", Type.EmptyTypes, "Teeth_Despawn_Pre");
		MassPatched = P(h, typeof(DEN_DeathFloor), "Update", Type.EmptyTypes, "Mass_Update_Pre");
		Plugin.Log.LogInfo((object)("Patches: " + ok + " applied, " + failed + " failed."));
	}

	private static bool P(Harmony h, Type t, string method, Type[] args, string prefix, string postfix = null, string finalizer = null)
	{
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			MethodInfo methodInfo = ((args == null) ? AccessTools.Method(t, method, (Type[])null, (Type[])null) : AccessTools.Method(t, method, args, (Type[])null));
			if (methodInfo == null)
			{
				throw new MissingMethodException(t.Name, method);
			}
			h.Patch((MethodBase)methodInfo, (prefix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(Patches), prefix, (Type[])null), (postfix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(Patches), postfix, (Type[])null), (HarmonyMethod)null, (finalizer == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(Patches), finalizer, (Type[])null), (HarmonyMethod)null);
			ok++;
			return true;
		}
		catch (Exception ex)
		{
			failed++;
			Plugin.Log.LogWarning((object)("Could not patch " + t.Name + "." + method + ": " + ex.Message + " (that rule is off)"));
			return false;
		}
	}

	private static void FillSettings_Pre(UI_GamemodeScreen_Panel __instance)
	{
		try
		{
			Mode.EnsureInjected(__instance.GetGamemode());
		}
		catch (Exception ex)
		{
			Util.LogOnce("fill", "Inject failed: " + ex.Message);
		}
	}

	private static Exception SettingInit_Finalizer(Exception __exception, GamemodeSetting setting)
	{
		if (__exception == null)
		{
			return null;
		}
		if ((Object)(object)setting == (Object)null || setting.id != "skmod_super")
		{
			return __exception;
		}
		Plugin.Log.LogError((object)("SUPER HARD button failed to build, removing it so the menu keeps working: " + __exception));
		Mode.Broken = true;
		return null;
	}

	private static Exception FillSettings_Finalizer(Exception __exception)
	{
		if (__exception != null && !Mode.Broken && (Object)(object)Mode.Setting != (Object)null)
		{
			Plugin.Log.LogError((object)("Run setup crashed with SUPER HARD added, removing it: " + __exception));
			Mode.Broken = true;
			Mode.RemoveEverywhere();
		}
		return __exception;
	}

	private static void ScreenInit_Pre(M_Gamemode mode)
	{
		try
		{
			Mode.EnsureInjected(mode);
		}
		catch (Exception ex)
		{
			Util.LogOnce("init", "Inject failed: " + ex.Message);
		}
	}

	private static bool ForcedId(string id)
	{
		if (id != null && id != "skmod_super")
		{
			if (!Cfg.ForceHardMode.Value || !Mode.HardIds.Contains(id))
			{
				if (Cfg.ForceSurvival.Value)
				{
					return Mode.SurvivalIds.Contains(id);
				}
				return false;
			}
			return true;
		}
		return false;
	}

	private static void HasActiveSetting_Post(M_Gamemode __instance, string id, ref bool __result)
	{
		if (!__result && !Mode.InCheck && ForcedId(id) && Mode.IsOnFor(__instance))
		{
			__result = true;
		}
	}

	private static void GetActiveSettings_Post(M_Gamemode __instance, ref List<GamemodeSetting> __result)
	{
		if (Mode.InCheck || (Object)(object)__instance == (Object)null || __instance.gamemodeSettings == null || !Mode.IsOnFor(__instance))
		{
			return;
		}
		List<GamemodeSetting> list = ((__result != null) ? new List<GamemodeSetting>(__result) : new List<GamemodeSetting>());
		foreach (GamemodeSetting gamemodeSetting in __instance.gamemodeSettings)
		{
			if ((Object)(object)gamemodeSetting != (Object)null && ForcedId(gamemodeSetting.id) && !list.Contains(gamemodeSetting))
			{
				list.Add(gamemodeSetting);
			}
		}
		__result = list;
	}

	private static void ModeIsHard_Post(M_Gamemode __instance, ref bool __result)
	{
		if (!__result && Cfg.ForceHardMode.Value && !Mode.InCheck && Mode.IsOnFor(__instance))
		{
			__result = true;
		}
	}

	private static void GameIsHard_Post(ref bool __result)
	{
		if (!__result && Cfg.ForceHardMode.Value && !Mode.InCheck && Mode.IsActive())
		{
			__result = true;
		}
	}

	private static bool Trinket_Activate_Pre(Trinket __instance)
	{
		if ((Object)(object)__instance == (Object)null || __instance.isBinding || Buddy.Granting || !Mode.IsActive())
		{
			return true;
		}
		Util.Debug("Trinket blocked: " + __instance.title);
		return false;
	}

	private static void HandItemUse_Pre(HandItem __instance)
	{
		if ((Object)(object)__instance == (Object)null || !Mode.IsActive())
		{
			return;
		}
		try
		{
			Buddy.OnUse(__instance.item);
		}
		catch
		{
		}
	}

	private static void HandStamina_Pre(Hand curhand, out float __state)
	{
		__state = curhand?.gripStrength ?? (-1f);
	}

	private static void HandStamina_Post(ENT_Player __instance, Hand curhand, float __state)
	{
		if (__state < 0f || curhand == null || !Mode.IsActive())
		{
			return;
		}
		try
		{
			if (!curhand.IsHanging() || PlayerRules.HasInfiniteStamina(__instance))
			{
				return;
			}
			float gripStrengthMax = curhand.GetGripStrengthMax();
			if (!(gripStrengthMax <= 0f))
			{
				float num = __state - gripStrengthMax / Mathf.Max(0.25f, Cfg.HangSeconds.Value) * Time.deltaTime;
				if (curhand.gripStrength > num)
				{
					curhand.gripStrength = Mathf.Max(0f, num);
				}
			}
		}
		catch (Exception ex)
		{
			Util.LogOnce("stam", "Grip drain failed: " + ex.Message);
		}
	}

	private static void PlayerDamage_Post(ENT_Player __instance)
	{
		if (!hopperHit)
		{
			return;
		}
		hopperHit = false;
		if ((Object)(object)__instance == (Object)null || ((GameEntity)__instance).dead)
		{
			return;
		}
		Util.Debug("Hopper roach hit - instant death.");
		try
		{
			((GameEntity)__instance).Kill("hopper", DamageInfo.CreateDamageInfo(99999f, "hopper"));
		}
		catch (Exception ex)
		{
			Util.LogOnce("hopkill", "Hopper kill failed: " + ex.Message);
		}
	}

	private static void PlayerDamage_Pre(DamageInfo info)
	{
		hopperHit = false;
		if (info == null || !Mode.IsActive())
		{
			return;
		}
		try
		{
			GameObject val = (((Object)(object)info.sourceEntity != (Object)null) ? ((Component)info.sourceEntity).gameObject : info.sourceObject);
			string text = ((((Object)(object)val != (Object)null) ? (((Object)val).name + " " + ((Object)val.transform.root).name) : "") + " " + info.type + " " + ((info.tags != null) ? string.Join(" ", info.tags.ToArray()) : "")).ToLowerInvariant();
			Zone current = Zones.Current;
			float amount = info.amount;
			if ((Object)(object)val != (Object)null && Cfg.HopperInstakill.Value)
			{
				DEN_Hopper componentInParent = val.GetComponentInParent<DEN_Hopper>();
				if ((Object)(object)componentInParent != (Object)null && !(componentInParent is DEN_Hopper_Tick) && (((object)componentInParent).GetType() == typeof(DEN_Hopper) || ((Object)((Component)componentInParent).gameObject).name.ToLowerInvariant().Contains("hopper")))
				{
					info.amount = 99999f;
					hopperHit = true;
				}
			}
			if (current == Zone.Silos && text.Contains("sturge"))
			{
				info.amount *= Cfg.SturgeDamageMult.Value;
			}
			if (current == Zone.Pipeworks && text.Contains("steam"))
			{
				info.amount *= Cfg.SteamDamageMult.Value;
			}
			if (current == Zone.Habitation && (text.Contains("turret") || ((Object)(object)val != (Object)null && ((Object)(object)val.GetComponentInParent<DEN_Turret>() != (Object)null || (Object)(object)val.GetComponentInParent<DEN_GantryTurret>() != (Object)null))))
			{
				info.amount *= Cfg.TurretDamageMult.Value;
			}
			if (info.amount != amount)
			{
				Util.DebugOnce("dmg" + text, "Damage " + amount + " -> " + info.amount + " from: " + text);
			}
		}
		catch (Exception ex)
		{
			Util.LogOnce("pdmg", "Damage rule failed: " + ex.Message);
		}
	}

	private static bool IsHammer(HandItem_Melee m)
	{
		if ((Object)(object)m != (Object)null && ((object)m).GetType() == typeof(HandItem_Melee) && !m.banHammer)
		{
			return ((Object)((Component)m).gameObject).name.ToLowerInvariant().Contains("hammer");
		}
		return false;
	}

	private static void Melee_Pre(HandItem_Melee __instance, out Vector2 __state)
	{
		//IL_000b: 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_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		__state = new Vector2(float.NaN, float.NaN);
		if (IsHammer(__instance) && Mode.IsActive())
		{
			__state = new Vector2(__instance.damage, __instance.chargeAttackDamage);
			__instance.damage *= Cfg.HammerDamageMult.Value;
			__instance.chargeAttackDamage *= Cfg.HammerDamageMult.Value;
		}
	}

	private static void Melee_Post(HandItem_Melee __instance, Vector2 __state)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		if (!float.IsNaN(__state.x) && !((Object)(object)__instance == (Object)null))
		{
			__instance.damage = __state.x;
			__instance.chargeAttackDamage = __state.y;
		}
	}

	private static void RandomCheck_Post(SpawnSettings __instance, ref bool __result)
	{
		if (__instance == null || !Mode.IsActive())
		{
			return;
		}
		try
		{
			SpawnRules.Decide(__instance, ref __result);
		}
		catch (Exception ex)
		{
			Util.LogOnce("rc", "Spawn rule failed: " + ex.Message);
		}
	}

	private static void SpawnChance_Pre(UT_SpawnChance __instance)
	{
		if (!Mode.IsActive())
		{
			return;
		}
		try
		{
			SpawnRules.RegisterComponent((MonoBehaviour)(object)__instance, __instance.spawnSettings, (UnityEventBase)(object)__instance.onSuccess, "");
		}
		catch
		{
		}
	}

	private static void EventChance_Pre(UT_EventChance __instance)
	{
		if (!Mode.IsActive())
		{
			return;
		}
		try
		{
			SpawnRules.RegisterComponent((MonoBehaviour)(object)__instance, __instance.spawnSettings, (UnityEventBase)(object)__instance.successEvent, "");
		}
		catch
		{
		}
	}

	private static void SpawnById_Pre(UT_SpawnEntityByID __instance)
	{
		if (!Mode.IsActive())
		{
			return;
		}
		try
		{
			string extra = __instance.idToSpawn + " " + SpawnRules.PrefabDescription(__instance.idToSpawn, __instance.customDatabase);
			SpawnRules.RegisterComponent((MonoBehaviour)(object)__instance, __instance.spawnSettings, null, extra);
		}
		catch
		{
		}
	}

	private static void SpawnTable_Pre(SpawnTable __instance)
	{
		if (!Mode.IsActive())
		{
			return;
		}
		try
		{
			SpawnRules.RegisterTable(__instance);
		}
		catch
		{
		}
	}

	private static bool AddPerk_Pre(Perk perk, ref Perk __result)
	{
		if ((Object)(object)perk == (Object)null || !Cfg.CavityRoute.Value || !Mode.IsActive())
		{
			return true;
		}
		if (!CavityRoute.IsAmalgam(perk.id + " " + perk.title + " " + ((Object)perk).name))
		{
			return true;
		}
		Util.Debug("No Amalgamator on Super Hard: blocked perk " + perk.id);
		__result = null;
		return false;
	}

	private static void LeaveChamber_Post(UT_ChamberLoader __instance)
	{
		if (Mode.IsActive())
		{
			Util.Debug("Left chamber via " + (((Object)(object)__instance != (Object)null) ? ((Object)((Component)__instance).gameObject).name : "?"));
			CavityRoute.OnChamberLeft();
		}
	}

	private static void Branch_Pre(UT_BranchGenerator __instance)
	{
		if (Mode.IsActive() && !((Object)(object)__instance == (Object)null))
		{
			Util.Debug("Moving into branch from " + ((Object)((Component)__instance).gameObject).name + " (level " + (((Object)(object)__instance.currentLevel != (Object)null) ? __instance.currentLevel.levelName : "?") + ")");
		}
	}

	private static void SetGameFlag_Pre(string name, bool state)
	{
		if (Mode.IsActive() && !(name == "skmod_run_cavity_done"))
		{
			if (!name.StartsWith("unlock_"))
			{
				Util.DebugOnce("flag" + name + state, "Game flag set: " + name + " = " + state + "   [" + Zones.Where + "]");
			}
			CavityRoute.OnFlag(name, state);
		}
	}

	private static void Button_Post(CL_Button __instance)
	{
		if ((Object)(object)__instance == (Object)null || !__instance.hasBeenPressed || !Mode.IsActive())
		{
			return;
		}
		try
		{
			Timers.OnButtonPressed((Component)(object)__instance);
		}
		catch
		{
		}
	}

	private static void HoldButton_Post(CL_HoldButton __instance)
	{
		if ((Object)(object)__instance == (Object)null || !__instance.hasFinished || Zones.Current != Zone.Nest || !Mode.IsActive())
		{
			return;
		}
		try
		{
			Timers.OnButtonPressed((Component)(object)__instance);
		}
		catch
		{
		}
	}

	private static bool TickStillSucking(DEN_Hopper_Tick t)
	{
		if ((Object)(object)t == (Object)null || !Cfg.TicksHoldOn.Value || tickAttached == null || tickDrained == null)
		{
			return false;
		}
		try
		{
			if (!tickAttached.Invoke(t))
			{
				return false;
			}
			GameEntity obj = ((tickTarget != null) ? tickTarget.Invoke(t) : null);
			ENT_Player val = (ENT_Player)(object)((obj is ENT_Player) ? obj : null);
			if (val == null || ((GameEntity)val).dead || CL_GameManager.isDead())
			{
				return false;
			}
			return tickDrained.Invoke(t) < t.maxBloodDrain;
		}
		catch
		{
			return false;
		}
	}

	private static bool Tick_Damage_Pre(DEN_Hopper_Tick __instance, ref bool __result)
	{
		if (!Mode.IsActive())
		{
			return true;
		}
		if (Zones.Current != Zone.Nest && !TickStillSucking(__instance))
		{
			return true;
		}
		__result = false;
		return false;
	}

	private static bool Tick_Detach_Pre(DEN_Hopper_Tick __instance)
	{
		if (!Mode.IsActive() || !TickStillSucking(__instance))
		{
			return true;
		}
		Util.DebugOnce("tickhold" + ((Object)__instance).GetInstanceID(), "Tick won't let go until it's full.");
		return false;
	}

	private static bool Tick_Kill_Pre(Denizen __instance)
	{
		if (Mode.IsActive())
		{
			DEN_Hopper_Tick val = (DEN_Hopper_Tick)(object)((__instance is DEN_Hopper_Tick) ? __instance : null);
			if (val != null)
			{
				return !TickStillSucking(val);
			}
		}
		return true;
	}

	private static bool Teeth_Despawn_Pre()
	{
		if (!Cfg.TeethStaysUntilHidden.Value || !Mode.IsActive() || Zones.Current != Zone.Habitation)
		{
			return true;
		}
		ENT_Player val = Util.Player();
		if ((Object)(object)val == (Object)null || ((GameEntity)val).dead || CL_GameManager.isDead())
		{
			return true;
		}
		float num = 1f;
		try
		{
			num = ((GameEntity)val).GetVisibility();
		}
		catch
		{
			return true;
		}
		if (num < Cfg.HiddenVisibility.Value)
		{
			Util.Debug("Hidden (visibility " + num.ToString("0.00") + ") - Teeth may leave.");
			return true;
		}
		Util.DebugOnce("teethstay", "Teeth tried to leave but you're not hidden (visibility " + num.ToString("0.00") + ").");
		return false;
	}

	private static void Mass_Update_Pre(DEN_DeathFloor __instance)
	{
		ApplyMass(__instance);
	}

	internal static void ApplyMass(DEN_DeathFloor __instance)
	{
		if ((Object)(object)__instance == (Object)null || !Mode.IsActive())
		{
			return;
		}
		float num = Cfg.MassSpeedMult.Value;
		if (Zones.Current == Zone.Silos)
		{
			num *= Cfg.SilosMassMult.Value;
		}
		else if (Zones.Current == Zone.Nest && Zones.NestLastSection)
		{
			float num2 = 1f;
			if ((Object)(object)CL_EventManager.currentSubregion != (Object)null && CL_EventManager.currentSubregion.massSpeedMult > 0.05f)
			{
				num2 *= CL_EventManager.currentSubregion.massSpeedMult;
			}
			if ((Object)(object)CL_EventManager.currentLevel != (Object)null && CL_EventManager.currentLevel.massSpeedMult > 0.05f)
			{
				num2 *= CL_EventManager.currentLevel.massSpeedMult;
			}
			num = ((Mathf.Abs(num2 - 1f) > 0.01f) ? (1f / num2) : 1f);
		}
		if (!(Mathf.Abs(num - 1f) > 0.001f))
		{
			return;
		}
		try
		{
			__instance.SetUpdateSpeedMultiplier(num);
		}
		catch (Exception ex)
		{
			Util.LogOnce("mass", "Mass speed failed: " + ex.Message);
		}
	}
}
internal static class PlayerRules
{
	private static ENT_Player gravityPlayer;

	private static float appliedMult = 1f;

	private static float poisonTimer;

	private static bool fallKillDone;

	private static readonly FieldRef<ENT_Player, bool> infiniteStamina = Util.SafeFieldRef<ENT_Player, bool>("infiniteStamina");

	public static void Reset()
	{
		gravityPlayer = null;
		appliedMult = 1f;
		poisonTimer = 0f;
		fallKillDone = false;
	}

	public static void Tick()
	{
		ENT_Player val = Util.Player();
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		if ((Object)(object)gravityPlayer != (Object)(object)val)
		{
			gravityPlayer = val;
			appliedMult = Cfg.GravityMult.Value;
			val.gravity *= appliedMult;
			Util.Debug("Gravity x" + appliedMult + " -> " + val.gravity);
		}
		if (((GameEntity)val).dead || CL_GameManager.isDead())
		{
			return;
		}
		if (Zones.Current == Zone.Nest && Cfg.NestWaterDps.Value > 0f && val.IsSwimming())
		{
			poisonTimer += Time.deltaTime;
			if (poisonTimer >= 0.5f)
			{
				poisonTimer = 0f;
				float num = Mathf.Max(1f, ((GameEntity)val).maxHealth * Cfg.NestWaterDps.Value / 100f * 0.5f);
				try
				{
					((GameEntity)val).Damage(DamageInfo.CreateDamageInfo(num, "poison"));
				}
				catch (Exception ex)
				{
					Util.LogOnce("poison", "Water poison failed: " + ex.Message);
				}
			}
		}
		else
		{
			poisonTimer = 0f;
		}
		if (Zones.Current == Zone.Abyss && !fallKillDone)
		{
			float num2 = 0f;
			try
			{
				num2 = val.GetCurrentFallDistance();
			}
			catch
			{
			}
			if (num2 >= Cfg.AbyssFallDeath.Value)
			{
				fallKillDone = true;
				Util.Debug("Fell " + num2.ToString("0") + " m in the Abyss - the nightmare takes you.");
				try
				{
					((GameEntity)val).Kill("nightmare", DamageInfo.CreateDamageInfo(99999f, "nightmare"));
				}
				catch (Exception ex2)
				{
					Util.LogOnce("fallkill", "Abyss fall kill failed: " + ex2.Message);
				}
			}
		}
		if (fallKillDone && !((GameEntity)val).dead)
		{
			fallKillDone = false;
		}
	}

	public static bool HasInfiniteStamina(ENT_Player p)
	{
		if (infiniteStamina == null || (Object)(object)p == (Object)null)
		{
			return false;
		}
		try
		{
			return infiniteStamina.Invoke(p);
		}
		catch
		{
			return false;
		}
	}
}
[BepInPlugin("com.wkmods.superhardknuckle", "SuperHardKnuckle", "1.0.12")]
public class Plugin : BaseUnityPlugin
{
	public const string GUID = "com.wkmods.superhardknuckle";

	public const string NAME = "SuperHardKnuckle";

	public const string VERSION = "1.0.12";

	internal static Plugin Instance;

	internal static ManualLogSource Log;

	internal static Harmony Harmony;

	private CL_GameManager lastGameManager;

	private float nextSlowTick;

	private void Awake()
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		Instance = this;
		Log = ((BaseUnityPlugin)this).Logger;
		Cfg.Bind(((BaseUnityPlugin)this).Config);
		Harmony = new Harmony("com.wkmods.superhardknuckle");
		Patches.ApplyAll(Harmony);
		Log.LogInfo((object)"SuperHardKnuckle 1.0.12 loaded. Pick SUPER HARD next to Hard Mode / Iron Knuckle on the run setup screen.");
	}

	private void Update()
	{
		try
		{
			Mode.MenuTick();
			CL_GameManager gMan = CL_GameManager.gMan;
			if ((Object)(object)gMan != (Object)(object)lastGameManager)
			{
				lastGameManager = gMan;
				if ((Object)(object)gMan != (Object)null)
				{
					OnNewRun();
				}
			}
			bool num = Mode.IsActive();
			Mode.ApplyGlobalToggles(num);
			if (num && !((Object)(object)gMan == (Object)null))
			{
				Zones.Tick();
				PlayerRules.Tick();
				EntityRules.Tick();
				Timers.Tick();
				CavityRoute.Tick();
				Buddy.Tick();
				SilosSturges.Tick();
				RedRoaches.Tick();
				if (!Patches.MassPatched)
				{
					Patches.ApplyMass(DEN_DeathFloor.instance);
				}
				if (Time.unscaledTime >= nextSlowTick)
				{
					nextSlowTick = Time.unscaledTime + 1f;
					ItemRules.SlowTick();
				}
			}
		}
		catch (Exception ex)
		{
			Util.LogOnce("update", "Update error: " + ex);
		}
	}

	private void OnNewRun()
	{
		EntityRules.Reset();
		ItemRules.Reset();
		Timers.Reset();
		PlayerRules.Reset();
		Zones.Reset();
		CavityRoute.Reset();
		Buddy.Reset();
		SilosSturges.Reset();
		RedRoaches.Reset();
		SpawnRules.RegisterAssetOwners();
		ClearOldSavedFlags();
	}

	private static void ClearOldSavedFlags()
	{
		string[] array = new string[2] { "skmod_buddy_given", "skmod_cavity_done" };
		foreach (string text in array)
		{
			try
			{
				if (CL_GameManager.HasActiveFlag(text, false))
				{
					CL_GameManager.SetGameFlag(text, false, "", true, false);
					Log.LogInfo((object)("Cleared leftover saved flag " + text));
				}
			}
			catch
			{
			}
		}
	}

	private void OnGUI()
	{
		try
		{
			Hud.Draw();
		}
		catch (Exception ex)
		{
			Util.LogOnce("gui", "HUD error: " + ex.Message);
		}
	}
}
internal static class Cfg
{
	public static ConfigEntry<bool> DebugLog;

	public static ConfigEntry<bool> ShowHud;

	public static ConfigEntry<bool> ForceHardMode;

	public static ConfigEntry<bool> ForceSurvival;

	public static ConfigEntry<bool> DisableLeaderboards;

	public static ConfigEntry<float> GravityMult;

	public static ConfigEntry<float> HangSeconds;

	public static ConfigEntry<float> HammerDamageMult;

	public static ConfigEntry<float> EngravedDoorChance;

	public static ConfigEntry<string> RedRoachKeywords;

	public static ConfigEntry<float> RemainsInterval;

	public static ConfigEntry<float> MassSpeedMult;

	public static ConfigEntry<bool> HopperInstakill;

	public static ConfigEntry<bool> TicksHoldOn;

	public static ConfigEntry<int> RedRoachExtra;

	public static ConfigEntry<float> RedRoachSpawnSeconds;

	public static ConfigEntry<int> RedRoachMax;

	public static ConfigEntry<int> TurretExtra;

	public static ConfigEntry<int> SilosSturgeExtra;

	public static ConfigEntry<bool> BuddyEnabled;

	public static ConfigEntry<float> BuddyPetSeconds;

	public static ConfigEntry<float> SilosSturgeInterval;

	public static ConfigEntry<int> SilosSturgeMax;

	public static ConfigEntry<int> SilosBloodbugExtra;

	public static ConfigEntry<float> SilosMassMult;

	public static ConfigEntry<float> SturgeDamageMult;

	public static ConfigEntry<string> TierOneMap;

	public static ConfigEntry<int> PipeworksBarnacleExtra;

	public static ConfigEntry<int> PipeworksHopperExtra;

	public static ConfigEntry<float> SteamDamageMult;

	public static ConfigEntry<bool> CavityRoute;

	public static ConfigEntry<string> ServiceShaftKeywords;

	public static ConfigEntry<string> AmalgamKeywords;

	public static ConfigEntry<float> RatKingSpeedMult;

	public static ConfigEntry<float> TeethSpeedMult;

	public static ConfigEntry<bool> TeethStaysUntilHidden;

	public static ConfigEntry<float> HiddenVisibility;

	public static ConfigEntry<float> VentThingSpeedMult;

	public static ConfigEntry<float> TurretDamageMult;

	public static ConfigEntry<float> TurretDroneChance;

	public static ConfigEntry<int> AbyssFaceCount;

	public static ConfigEntry<float> AbyssFallDeath;

	public static ConfigEntry<int> NestBarnacleExtra;

	public static ConfigEntry<float> MotherSeconds;

	public static ConfigEntry<int> MotherButtons;

	public static ConfigEntry<float> MotherRoomRadius;

	public static ConfigEntry<float> NestWaterDps;

	public static ConfigEntry<string> NestLastSectionKeywords;

	public static void Bind(ConfigFile c)
	{
		DebugLog = c.Bind<bool>("General", "DebugLog", true, "Write what the mod changes (zones, boosted spawns, clones, replaced items) to the BepInEx log. Handy for tuning.");
		ShowHud = c.Bind<bool>("General", "ShowHud", true, "Show the small SUPER HARD label and timers on screen.");
		ForceHardMode = c.Bind<bool>("General", "ForceHardMode", true, "Super Hard always includes vanilla Hard Mode.");
		ForceSurvival = c.Bind<bool>("General", "ForceSurvival", true, "Super Hard always turns on the Survival setting (if the gamemode has one).");
		DisableLeaderboards = c.Bind<bool>("General", "DisableLeaderboards", true, "Don't submit modded Super Hard runs to the online leaderboards.");
		GravityMult = c.Bind<float>("Global", "GravityMult", 1.2f, "Player gravity multiplier (1.2 = +20%).");
		HangSeconds = c.Bind<float>("Global", "HangSeconds", 3f, "A full grip drains in this many seconds while hanging.");
		HammerDamageMult = c.Bind<float>("Global", "HammerDamageMult", 0.6f, "Hammer damage multiplier.");
		EngravedDoorChance = c.Bind<float>("Global", "EngravedDoorChance", 0.4f, "Spawn chance for Engraved Doors.");
		RedRoachKeywords = c.Bind<string>("Global", "RedRoachNames", "roach_explosive,redroach,red_roach,roach_red", "Names that count as red roaches (the game calls them Denizen_Roach_Explosive).");
		RedRoachExtra = c.Bind<int>("Global", "RedRoachExtraCopies", 3, "Extra copies of every red roach that appears.");
		RedRoachSpawnSeconds = c.Bind<float>("Global", "RedRoachSpawnSeconds", 35f, "A red roach also spawns near you this often, everywhere (0 = off).");
		RedRoachMax = c.Bind<int>("Global", "RedRoachMaxAlive", 8, "Most extra red roaches from the timer alive at once.");
		TurretExtra = c.Bind<int>("Global", "TurretExtraCopies", 2, "Extra copies of every turret, and every turret spawn chance is forced on.");
		HopperInstakill = c.Bind<bool>("Global", "HopperRoachInstakill", true, "Getting hurt by a hopper roach (Denizen_Hopper) kills you instantly, everywhere.");
		TicksHoldOn = c.Bind<bool>("Global", "TicksCantBeThrownOff", true, "Tick roaches can't be thrown off or killed while latched on - they let go only once they've drunk their fill.");
		MassSpeedMult = c.Bind<float>("Global", "MassSpeedMult", 1.6f, "Mass speed everywhere. The Silos multiplier stacks on top of this, and the Nest's last section stays at 1x.");
		RemainsInterval = c.Bind<float>("Global", "RemainsIntervalSeconds", 600f, "A Remains spawns near you every this many seconds.");
		BuddyEnabled = c.Bind<bool>("Global", "CalmingBuddy", true, "You always start with the Calming Buddy and must pet it (use it in your hand) regularly or you die.");
		BuddyPetSeconds = c.Bind<float>("Global", "CalmingBuddyPetSeconds", 300f, "Seconds you can go without petting the Calming Buddy.");
		SilosSturgeInterval = c.Bind<float>("Silos", "SturgeEverySeconds", 25f, "A Sturge spawns near you this often in the Silos (0 = off).");
		SilosSturgeMax = c.Bind<int>("Silos", "SturgeMaxAlive", 8, "Most extra Sturges from the timer alive at once.");
		SilosSturgeExtra = c.Bind<int>("Silos", "SturgeExtraCopies", 1, "Extra copies of every Sturge that appears in the Silos.");
		SilosBloodbugExtra = c.Bind<int>("Silos", "BloodbugExtra", 1, "Extra copies of every bloodbug (any variant). 1 = double.");
		SilosMassMult = c.Bind<float>("Silos", "MassSpeedMult", 0.6f, "Mass speed multiplier in the Silos.");
		SturgeDamageMult = c.Bind<float>("Silos", "SturgeDamageMult", 2f, "Sturge damage multiplier.");
		TierOneMap = c.Bind<string>("Silos", "TierOneReplacements", "Item_RebarRope=Item_Rebar", "Extra item swaps for Silos (name=replacement; ...). Anything ending _T2/_T3 is swapped to _T1 automatically.");
		PipeworksBarnacleExtra = c.Bind<int>("Pipeworks", "BarnacleExtra", 1, "Extra copies of every barnacle in Pipeworks.");
		PipeworksHopperExtra = c.Bind<int>("Pipeworks", "HopperExtra", 1, "Extra copies of every hopper roach in Pipeworks.");
		SteamDamageMult = c.Bind<float>("Pipeworks", "SteamDamageMult", 2.5f, "Steam pipe damage multiplier.");
		CavityRoute = c.Bind<bool>("Habitation", "SecurityShaftNeedsBodyCavity", true, "The Security Shaft stays sealed until you beat the Body Cavity shortcut in this run. Beating it sends you back to the Habitation break room.");
		ServiceShaftKeywords = c.Bind<string>("Habitation", "ServiceShaftLevelKeywords", "habitation_shaft_0,habitation_shaft_1,habitation_shaft_to,security", "Level names that count as the shaft behind the break-room gate (the game calls it Service Shaft). The break room (M3_Habitation_Shaft_Intro) never counts.");
		AmalgamKeywords = c.Bind<string>("Habitation", "AmalgamatorKeywords", "amalgam", "Items/perks with these names are never given out (the Amalgamator).");
		RatKingSpeedMult = c.Bind<float>("Habitation", "RatKingSpeedMult", 2.5f, "Rat King speed multiplier.");
		TeethSpeedMult = c.Bind<float>("Habitation", "TeethSpeedMult", 1.8f, "Teeth speed multiplier.");
		TeethStaysUntilHidden = c.Bind<bool>("Habitation", "TeethStaysUntilHidden", true, "Teeth won't despawn until you are hidden.");
		HiddenVisibility = c.Bind<float>("Habitation", "HiddenVisibility", 0.35f, "You count as hidden when the game's visibility value is below this.");
		VentThingSpeedMult = c.Bind<float>("Habitation", "VentThingSpeedMult", 1.8f, "Vent thing hand speed and pull multiplier.");
		TurretDamageMult = c.Bind<float>("Habitation", "TurretDamageMult", 2f, "Turret damage multiplier.");
		TurretDroneChance = c.Bind<float>("Habitation", "TurretDroneChance", 0.5f, "Chance a drone spawns next to each turret.");
		AbyssFaceCount = c.Bind<int>("Abyss", "FaceCount", 5, "How many faces hunt you in the Abyss.");
		AbyssFallDeath = c.Bind<float>("Abyss", "FallDeathMeters", 100f, "Falling this far in the Abyss kills you.");
		NestBarnacleExtra = c.Bind<int>("Nest", "BarnacleExtra", 2, "Extra copies of every barnacle in the Nest.");
		MotherSeconds = c.Bind<float>("Nest", "MotherSeconds", 30f, "Seconds you get near the Mother before she kills you.");
		MotherButtons = c.Bind<int>("Nest", "MotherSavedAfterButtons", 3, "Pressing this many different buttons in the Mother's room saves her and stops the timer.");
		MotherRoomRadius = c.Bind<float>("Nest", "MotherRoomRadius", 80f, "Buttons within this many metres of the Mother count as hers.");
		NestWaterDps = c.Bind<float>("Nest", "WaterPoisonPercentPerSecond", 8f, "Percent of max health lost per second while in Nest water.");
		NestLastSectionKeywords = c.Bind<string>("Nest", "LastSectionKeywords", "mother", "Level/subregion names that count as the Nest's last section (the final subregion always counts).");
	}
}
internal static class SpawnRules
{
	private sealed class RefEq : IEqualityComparer<SpawnSettings>
	{
		public bool Equals(SpawnSettings a, SpawnSettings b)
		{
			return a == b;
		}

		public int GetHashCode(SpawnSettings s)
		{
			return RuntimeHelpers.GetHashCode(s);
		}
	}

	private static readonly Dictionary<SpawnSettings, string> owners = new Dictionary<SpawnSettings, string>(new RefEq());

	private static string[] redRoachKeys;

	public static void RegisterAssetOwners()
	{
		redRoachKeys = null;
		try
		{
			WKAssetDatabase val = Util.Db();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if (val.sessionEvents != null)
			{
				foreach (SessionEvent sessionEvent in val.sessionEvents)
				{
					if ((Object)(object)sessionEvent != (Object)null && sessionEvent.spawnSettings != null)
					{
						owners[sessionEvent.spawnSettings] = ("event " + sessionEvent.id + " " + ((Object)sessionEvent).name).ToLowerInvariant();
					}
				}
			}
			if (val.subRegionAssets != null)
			{
				foreach (M_Subregion subRegionAsset in val.subRegionAssets)
				{
					if ((Object)(object)subRegionAsset != (Object)null && subRegionAsset.spawnSettings != null)
					{
						owners[subRegionAsset.spawnSettings] = ("subregion " + ((Object)subRegionAsset).name + " " + subRegionAsset.subregionName).ToLowerInvariant();
					}
				}
			}
			if (val.perkAssets == null)
			{
				return;
			}
			foreach (Perk perkAsset in val.perkAssets)
			{
				if ((Object)(object)perkAsset != (Object)null && perkAsset.spawnSettings != null)
				{
					owners[perkAsset.spawnSettings] = ("perk " + perkAsset.id).ToLowerInvariant();
				}
			}
		}
		catch (Exception ex)
		{
			Util.LogOnce("owners", "Spawn owner scan failed: " + ex.Message);
		}
	}

	public static void RegisterComponent(MonoBehaviour c, SpawnSettings s, UnityEventBase ev, string extra)
	{
		if (!((Object)(object)c == (Object)null) && s != null && !owners.ContainsKey(s))
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(((object)c).GetType().Name).Append(' ').Append(extra)
				.Append(' ');
			Transform val = ((Component)c).transform;
			int num = 0;
			while (num < 3 && (Object)(object)val != (Object)null)
			{
				stringBuilder.Append(((Object)val).name).Append(' ');
				num++;
				val = val.parent;
			}
			if (ev != null)
			{
				DescribeEvent(ev, stringBuilder);
			}
			owners[s] = stringBuilder.ToString().ToLowerInvariant();
		}
	}

	public static void RegisterTable(SpawnTable table)
	{
		if ((Object)(object)table == (Object)null || table.spawnList == null)
		{
			return;
		}
		foreach (SpawnTableAsset spawn in table.spawnList)
		{
			if (spawn == null || spawn.spawnSettings == null || owners.ContainsKey(spawn.spawnSettings))
			{
				continue;
			}
			StringBuilder stringBuilder = new StringBuilder("table ").Append(((Object)table).name).Append(' ').Append(spawn.name)
				.Append(' ');
			if (spawn.prefabs != null)
			{
				foreach (GameObject prefab in spawn.prefabs)
				{
					if ((Object)(object)prefab != (Object)null)
					{
						DescribeHierarchy(prefab, stringBuilder);
					}
				}
			}
			owners[spawn.spawnSettings] = stringBuilder.ToString().ToLowerInvariant();
		}
	}

	public static string PrefabDescription(string id, string database)
	{
		try
		{
			GameObject assetGameObject = CL_AssetManager.GetAssetGameObject(id, database);
			if ((Object)(object)assetGameObject == (Object)null)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			DescribeHierarchy(assetGameObject, stringBuilder);
			return stringBuilder.ToString();
		}
		catch
		{
			return "";
		}
	}

	private static void DescribeEvent(UnityEventBase ev, StringBuilder sb)
	{
		int persistentEventCount = ev.GetPersistentEventCount();
		for (int i = 0; i < persistentEventCount; i++)
		{
			Object persistentTarget = ev.GetPersistentTarget(i);
			if (persistentTarget == (Object)null)
			{
				continue;
			}
			GameObject val = (GameObject)(object)((persistentTarget is GameObject) ? persistentTarget : null);
			if ((Object)(object)val == (Object)null)
			{
				Component val2 = (Component)(object)((persistentTarget is Component) ? persistentTarget : null);
				if (val2 != null)
				{
					val = val2.gameObject;
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				DescribeHierarchy(val, sb);
			}
			else
			{
				sb.Append(persistentTarget.name).Append(' ');
			}
		}
	}

	private static void DescribeHierarchy(GameObject g, StringBuilder sb)
	{
		sb.Append(((Object)g).name).Append(' ');
		if (g.GetComponentsInChildren<Transform>(true).Length > 40)
		{
			return;
		}
		HashSet<string> hashSet = new HashSet<string>();
		MonoBehaviour[] componentsInChildren = g.GetComponentsInChildren<MonoBehaviour>(true);
		foreach (MonoBehaviour val in componentsInChildren)
		{
			if (!((Object)(object)val == (Object)null))
			{
				if (val is GameEntity)
				{
					hashSet.Add(((object)val).GetType().Name);
				}
				UT_SpawnEntityByID val2 = (UT_SpawnEntityByID)(object)((val is UT_SpawnEntityByID) ? val : null);
				if (val2 != null)
				{
					sb.Append(val2.idToSpawn).Append(' ');
				}
			}
		}
		foreach (string item in hashSet)
		{
			sb.Append(item).Append(' ');
		}
	}

	public static void Decide(SpawnSettings s, ref bool result)
	{
		if (owners.TryGetValue(s, out var value) && !string.IsNullOrEmpty(value))
		{
			float? num = null;
			string text = null;
			if (Zones.Current == Zone.Habitation && value.Contains("cavity"))
			{
				num = 1f;
				text = "body cavity forced";
			}
			else if (IsRedRoach(value))
			{
				num = 1f;
				text = "red roach always";
			}
			else if (value.Contains("turret"))
			{
				num = 1f;
				text = "turrets always";
			}
			else if (value.Contains("engraved"))
			{
				num = Cfg.EngravedDoorChance.Value;
				text = "engraved door " + (Cfg.EngravedDoorChance.Value * 100f).ToString("0") + "%";
			}
			if (num.HasValue)
			{
				bool flag = result;
				result = num.Value >= 1f || Random.value < num.Value;
				Util.DebugOnce(text + value, "Spawn rule '" + text + "' on: " + Short(value) + " (" + flag + " -> " + result + ")");
			}
		}
	}

	public static bool IsRedRoach(string desc)
	{
		string[] array;
		if (redRoachKeys == null)
		{
			List<string> list = new List<string>();
			array = Cfg.RedRoachKeywords.Value.Split(',');
			foreach (string text in array)
			{
				if (text.Trim().Length > 0)
				{
					list.Add(text.Trim().ToLowerInvariant());
				}
			}
			redRoachKeys = list.ToArray();
		}
		array = redRoachKeys;
		foreach (string value in array)
		{
			if (desc.Contains(value))
			{
				return true;
			}
		}
		return false;
	}

	private static string Short(string s)
	{
		if (s.Length <= 160)
		{
			return s;
		}
		return s.Substring(0, 160) + "...";
	}
}
internal static class Timers
{
	public static float RemainsTimer;

	public static float MotherLeft = -1f;

	private static DEN_Mother timedMother;

	private static bool motherDone;

	private static bool motherSaved;

	private static readonly HashSet<int> motherButtons = new HashSet<int>();

	public static void Reset()
	{
		RemainsTimer = 0f;
		MotherLeft = -1f;
		timedMother = null;
		motherDone = false;
		motherSaved = false;
		motherButtons.Clear();
	}

	public static void Tick()
	{
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		ENT_Player val = Util.Player();
		if ((Object)(object)val == (Object)null || ((GameEntity)val).dead || CL_GameManager.isDead() || ((Object)(object)CL_GameManager.gMan != (Object)null && CL_GameManager.gMan.isPaused))
		{
			return;
		}
		RemainsTimer += Time.deltaTime;
		if (RemainsTimer >= Cfg.RemainsInterval.Value)
		{
			RemainsTimer = 0f;
			SpawnRemains();
		}
		if (Zones.Current == Zone.Nest)
		{
			DEN_Mother instance = DEN_Mother.instance;
			if ((Object)(object)instance != (Object)null && ((Component)instance).gameObject.activeInHierarchy && !((GameEntity)instance).dead)
			{
				if ((Object)(object)instance != (Object)(object)timedMother)
				{
					timedMother = instance;
					MotherLeft = -1f;
					motherDone = false;
					motherSaved = false;
					motherButtons.Clear();
				}
				if (motherSaved)
				{
					MotherLeft = -1f;
					return;
				}
				float num = Vector3.Distance(((Component)val).transform.position, ((Component)instance).transform.position);
				if (MotherLeft < 0f && !motherDone && num < 35f)
				{
					MotherLeft = Cfg.MotherSeconds.Value;
					Util.Debug("Mother section: " + MotherLeft + " seconds.");
				}
				if (!(MotherLeft >= 0f))
				{
					return;
				}
				if (num > 70f)
				{
					MotherLeft = -1f;
					motherDone = true;
					Util.Debug("Made it past the Mother.");
					return;
				}
				MotherLeft -= Time.deltaTime;
				if (MotherLeft <= 0f)
				{
					MotherLeft = -1f;
					motherDone = true;
					Util.Debug("Mother timer ran out.");
					try
					{
						instance.Enrage(true);
					}
					catch (Exception ex)
					{
						Util.LogOnce("enrage", "Enrage failed: " + ex.Message);
					}
					try
					{
						instance.KillPlayer();
					}
					catch (Exception ex2)
					{
						Util.LogOnce("motherkill", "Mother kill failed: " + ex2.Message);
					}
				}
			}
			else if (MotherLeft >= 0f)
			{
				MotherLeft = -1f;
				motherDone = true;
			}
		}
		else
		{
			MotherLeft = -1f;
		}
	}

	public static void OnButtonPressed(Component button)
	{
		//IL_0037: 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)
		if ((Object)(object)button == (Object)null || motherSaved || Zones.Current != Zone.Nest)
		{
			return;
		}
		DEN_Mother instance = DEN_Mother.instance;
		if (!((Object)(object)instance == (Object)null) && !((GameEntity)instance).dead && !(Vector3.Distance(button.transform.position, ((Component)instance).transform.position) > Cfg.MotherRoomRadius.Value) && motherButtons.Add(((Object)button).GetInstanceID()))
		{
			Util.Debug("Mother's room button pressed: " + ((Object)button.gameObject).name + " (" + motherButtons.Count + "/" + Cfg.MotherButtons.Value + ")");
			if (motherButtons.Count >= Cfg.MotherButtons.Value)
			{
				motherSaved = true;
				motherDone = true;
				timedMother = instance;
				MotherLeft = -1f;
				Util.Debug("The Mother is saved - her timer stops.");
				Hud.Flash("SHE IS SAVED");
			}
		}
	}

	private unsafe static void SpawnRemains()
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = Util.FindPrefabWith<DEN_Remains_Active>();
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		if (!Util.SpotAroundPlayer(14f, 26f, out var pos))
		{
			RemainsTimer = Cfg.RemainsInterval.Value - 15f;
			return;
		}
		Transform parent = null;
		try
		{
			parent = WorldLoader.GetCurrentLevelParentRoot();
		}
		catch
		{
		}
		GameObject val2 = Util.Spawn(val, pos, Quaternion.Euler(0f, Random.Range(0f, 360f), 0f), parent);
		DEN_Remains_Active val3 = (((Object)(object)val2 != (Object)null) ? val2.GetComponentInChildren<DEN_Remains_Active>(true) : null);
		if ((Object)(object)val3 != (Object)null)
		{
			val3.active = true;
		}
		Util.Debug("Remains spawned at " + ((object)(*(Vector3*)(&pos))/*cast due to .constrained prefix*/).ToString() + " (" + (((Object)(object)val2 != (Object)null) ? ((Object)val2).name : "failed") + ")");
		Hud.Flash("Something remains...");
	}
}
internal static class Util
{
	private static readonly HashSet<string> once = new HashSet<string>();

	private static WKAssetDatabase dbCache;

	private static int dbScene = -1;

	private static CL_GameManager dbGameManager;

	private static float dbRetryAt;

	private static readonly Dictionary<Type, GameObject> prefabByType = new Dictionary<Type, GameObject>();

	private static readonly Dictionary<string, GameObject> itemByName = new Dictionary<string, GameObject>(StringComparer.OrdinalIgnoreCase);

	private static readonly Dictionary<string, GameObject> prefabByName = new Dictionary<string, GameObject>();

	public static void Debug(string msg)
	{
		if (Cfg.DebugLog != null && Cfg.DebugLog.Value)
		{
			Plugin.Log.LogInfo((object)msg);
		}
	}

	public static void DebugOnce(string key, string msg)
	{
		if (once.Add("d:" + key))
		{
			Debug(msg);
		}
	}

	public static void LogOnce(string key, string msg)
	{
		if (once.Add("e:" + key))
		{
			Plugin.Log.LogWarning((object)msg);
		}
	}

	public static string Clean(string n)
	{
		if (n == null)
		{
			return "";
		}
		int num = n.IndexOf("(Clone)", StringComparison.Ordinal);
		if (num >= 0)
		{
			n = n.Substring(0, num);
		}
		return n.Trim();
	}

	public static ENT_Player Player()
	{
		try
		{
			return ENT_Player.GetPlayer();
		}
		catch
		{
			return null;
		}
	}

	public static WKAssetDatabase Db()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		Scene activeScene = SceneManager.GetActiveScene();
		int num = SceneHandle.op_Implicit(((Scene)(ref activeScene)).handle);
		if (num != dbScene || (Object)(object)CL_GameManager.gMan != (Object)(object)dbGameManager || ((Object)(object)dbCache == (Object)null && Time.unscaledTime >= dbRetryAt))
		{
			dbRetryAt = Time.unscaledTime + 5f;
			dbScene = num;
			dbGameManager = CL_GameManager.gMan;
			try
			{
				dbCache = CL_AssetManager.GetFullCombinedAssetDatabase();
			}
			catch
			{
				dbCache = null;
			}
		}
		return dbCache;
	}

	public static void ResetCaches()
	{
		prefabByType.Clear();
		itemByName.Clear();
		prefabByName.Clear();
	}

	public static GameObject FindPrefabWith<T>() where T : Component
	{
		if (prefabByType.TryGetValue(typeof(T), out var value) && (Object)(object)value != (Object)null)
		{
			return value;
		}
		GameObject val = null;
		try
		{
			WKAssetDatabase val2 = Db();
			if ((Object)(object)val2 != (Object)null)
			{
				val = Scan<T>(val2.denizenPrefabs) ?? Scan<T>(val2.entityPrefabs);
			}
			if ((Object)(object)val == (Object)null && (Object)(object)CL_GameManager.gMan != (Object)null && CL_GameManager.gMan.gameEntityPrefabs != null)
			{
				foreach (GameEntity gameEntityPrefab in CL_GameManager.gMan.gameEntityPrefabs)
				{
					if ((Object)(object)gameEntityPrefab != (Object)null && (Object)(object)((Component)gameEntityPrefab).GetComponentInChildren<T>(true) != (Object)null)
					{
						val = ((Component)gameEntityPrefab).gameObject;
						break;
					}
				}
			}
		}
		catch (Exception ex)
		{
			LogOnce("prefab" + typeof(T).Name, "Prefab search for " + typeof(T).Name + " failed: " + ex.Message);
		}
		prefabByType[typeof(T)] = val;
		if ((Object)(object)val == (Object)null)
		{
			LogOnce("noprefab" + typeof(T).Name, "No prefab with " + typeof(T).Name + " found, that rule is skipped.");
		}
		else
		{
			Debug("Using prefab '" + ((Object)val).name + "' for " + typeof(T).Name);
		}
		return val;
	}

	public static GameObject FindPrefabNamed(string part)
	{
		part = part.ToLowerInvariant();
		if (prefabByName.TryGetValue(part, out var value) && (Object)(object)value != (Object)null)
		{
			return value;
		}
		GameObject val = null;
		try
		{
			WKAssetDatabase val2 = Db();
			List<List<GameObject>> list = new List<List<GameObject>>();
			if ((Object)(object)val2 != (Object)null)
			{
				list.Add(val2.denizenPrefabs);
				list.Add(val2.entityPrefabs);
			}
			foreach (List<GameObject> item in list)
			{
				if (item == null)
				{
					continue;
				}
				foreach (GameObject item2 in item)
				{
					if (!((Object)(object)item2 == (Object)null))
					{
						string text = ((Object)item2).name.ToLowerInvariant();
						if (text.Contains(part) && ((Object)(object)val == (Object)null || text == "denizen_" + part || (text.Length < ((Object)val).name.Length && ((Object)val).name.ToLowerInvariant() != "denizen_" + part)))
						{
							val = item2;
						}
					}
				}
			}
		}
		catch (Exception ex)
		{
			LogOnce("pname" + part, "Prefab search for '" + part + "' failed: " + ex.Message);
		}
		prefabByName[part] = val;
		if ((Object)(object)val == (Object)null)
		{
			LogOnce("nopname" + part, "No prefab named like '" + part + "' found, that rule is skipped.");
		}
		else
		{
			Debug("Using prefab '" + ((Object)val).name + "' for '" + part + "'");
		}
		return val;
	}

	private static GameObject Scan<T>(List<GameObject> list) where T : Component
	{
		if (list == null)
		{
			return null;
		}
		foreach (GameObject item in list)
		{
			if ((Object)(object)item != (Object)null && (Object)(object)item.GetComponentInChildren<T>(true) != (Object)null)
			{
				return item;
			}
		}
		return null;
	}

	public static GameObject ItemPrefab(string name)
	{
		if (string.IsNullOrEmpty(name))
		{
			return null;
		}
		if (itemByName.Count == 0)
		{
			try
			{
				WKAssetDatabase val = Db();
				if ((Object)(object)val != (Object)null && val.itemPrefabs != null)
				{
					foreach (GameObject itemPrefab in val.itemPrefabs)
					{
						if ((Object)(object)itemPrefab != (Object)null && !itemByName.ContainsKey(((Object)itemPrefab).name))
						{
							itemByName[((Object)itemPrefab).name] = itemPrefab;
						}
					}
				}
			}
			catch (Exception ex)
			{
				LogOnce("itemdb", "Item list failed: " + ex.Message);
			}
		}
		itemByName.TryGetValue(name, out var value);
		return value;
	}

	public static GameObject Spawn(GameObject prefab, Vector3 pos, Quaternion rot, Transform parent = null)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: 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_0028: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)prefab == (Object)null)
		{
			return null;
		}
		bool activeSelf = prefab.activeSelf;
		if (activeSelf)
		{
			prefab.SetActive(false);
		}
		GameObject val;
		try
		{
			val = (((Object)(object)parent != (Object)null) ? Object.Instantiate<GameObject>(prefab, pos, rot, parent) : Object.Instantiate<GameObject>(prefab, pos, rot));
		}
		finally
		{
			if (activeSelf)
			{
				prefab.SetActive(true);
			}
		}
		((Object)val).name = Clean(((Object)prefab).name);
		val.SetActive(true);
		return val;
	}

	public static Vector3 NearbySpot(Transform t)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: 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_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//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_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: 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_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: 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_0095: 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_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_018a: 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_00b0: 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_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_00cd: 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_00d4: 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_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_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: 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_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_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		Vector3 position = t.position;
		Vector3 up = t.up;
		float num = 0.05f;
		bool flag = false;
		RaycastHit val = default(RaycastHit);
		if (Physics.Raycast(position + up * 0.5f, -up, ref val, 3f, -1, (QueryTriggerInteraction)1) && !((Component)((RaycastHit)(ref val)).collider).transform.IsChildOf(t))
		{
			flag = true;
			num = Mathf.Max(0.02f, Vector3.Dot(position - ((RaycastHit)(ref val)).point, ((RaycastHit)(ref val)).normal));
		}
		RaycastHit val4 = default(RaycastHit);
		RaycastHit val5 = default(RaycastHit);
		for (int i = 0; i < 12; i++)
		{
			Vector3 val2 = Random.onUnitSphere;
			val2 -= Vector3.Project(val2, up);
			if (((Vector3)(ref val2)).sqrMagnitude < 0.01f)
			{
				continue;
			}
			((Vector3)(ref val2)).Normalize();
			Vector3 val3 = position + val2 * Random.Range(1.5f, 4f);
			if (!Physics.Linecast(position + up * 0.3f, val3 + up * 0.3f, ref val4, -1, (QueryTriggerInteraction)1) || ((Component)((RaycastHit)(ref val4)).collider).transform.IsChildOf(t))
			{
				if (!flag)
				{
					return val3;
				}
				if (Physics.Raycast(val3 + up * 1f, -up, ref val5, 4f, -1, (QueryTriggerInteraction)1) && !((Component)((RaycastHit)(ref val5)).collider).transform.IsChildOf(t))
				{
					return ((RaycastHit)(ref val5)).point + ((RaycastHit)(ref v