using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using GameConsole;
using GameConsole.CommandTree;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Steamworks;
using TMPro;
using ULTRAKILL.Portal;
using ULTRAKILL.Portal.Geometry;
using Ultrarogue;
using Ultrarogue.Characters;
using Ultrarogue.Items;
using Ultrarogue.SceneStuff;
using Unity.AI.Navigation;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.ResourceManagement.ResourceProviders;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using plog;
using plog.Models;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("Ultrarogue")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+002b2d0dd1b31b33aaacca1c3ed88f5968eb099f")]
[assembly: AssemblyProduct("My first plugin")]
[assembly: AssemblyTitle("Ultrarogue")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class AssetsManager
{
	[CompilerGenerated]
	private sealed class <GetAllEnemies>d__26 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		private AsyncOperationHandle<IResourceLocator> <initHandle>5__1;

		private List<IResourceLocation> <allLocations>5__2;

		private int <enemyCount>5__3;

		private IEnumerator<IResourceLocator> <>s__4;

		private IResourceLocator <locator>5__5;

		private List<object> <keys>5__6;

		private AsyncOperationHandle<IList<IResourceLocation>> <locHandle>5__7;

		private List<IResourceLocation>.Enumerator <>s__8;

		private IResourceLocation <location>5__9;

		private AsyncOperationHandle<SpawnableObject> <loadHandle>5__10;

		private SpawnableObject <obj>5__11;

		private Dictionary<EnemyType, List<SpawnableObject>>.Enumerator <>s__12;

		private KeyValuePair<EnemyType, List<SpawnableObject>> <kvp>5__13;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <GetAllEnemies>d__26(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			case -3:
			case 2:
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
				break;
			case -4:
			case 3:
				try
				{
				}
				finally
				{
					<>m__Finally2();
				}
				break;
			}
			<initHandle>5__1 = default(AsyncOperationHandle<IResourceLocator>);
			<allLocations>5__2 = null;
			<>s__4 = null;
			<locator>5__5 = null;
			<keys>5__6 = null;
			<locHandle>5__7 = default(AsyncOperationHandle<IList<IResourceLocation>>);
			<>s__8 = default(List<IResourceLocation>.Enumerator);
			<location>5__9 = null;
			<loadHandle>5__10 = default(AsyncOperationHandle<SpawnableObject>);
			<obj>5__11 = null;
			<>s__12 = default(Dictionary<EnemyType, List<SpawnableObject>>.Enumerator);
			<kvp>5__13 = default(KeyValuePair<EnemyType, List<SpawnableObject>>);
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_003d: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Invalid comparison between Unknown and I4
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Invalid comparison between Unknown and I4
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Invalid comparison between Unknown and I4
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<initHandle>5__1 = Addressables.InitializeAsync();
					<>2__current = <initHandle>5__1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<allLocations>5__2 = new List<IResourceLocation>();
					<>s__4 = Addressables.ResourceLocators.GetEnumerator();
					<>1__state = -3;
					goto IL_0168;
				case 2:
					<>1__state = -3;
					if ((int)<locHandle>5__7.Status == 1)
					{
						<allLocations>5__2.AddRange(<locHandle>5__7.Result);
					}
					Addressables.Release<IList<IResourceLocation>>(<locHandle>5__7);
					<keys>5__6 = null;
					<locHandle>5__7 = default(AsyncOperationHandle<IList<IResourceLocation>>);
					<locator>5__5 = null;
					goto IL_0168;
				case 3:
					{
						<>1__state = -4;
						if ((int)<loadHandle>5__10.Status != 1)
						{
							break;
						}
						<obj>5__11 = <loadHandle>5__10.Result;
						if ((int)<obj>5__11.spawnableObjectType == 1)
						{
							if (!enemiesByType.ContainsKey(<obj>5__11.enemyType))
							{
								enemiesByType[<obj>5__11.enemyType] = new List<SpawnableObject>();
							}
							enemiesByType[<obj>5__11.enemyType].Add(<obj>5__11);
							<enemyCount>5__3++;
							<loadHandle>5__10 = default(AsyncOperationHandle<SpawnableObject>);
							<obj>5__11 = null;
							<location>5__9 = null;
						}
						break;
					}
					IL_0168:
					while (<>s__4.MoveNext())
					{
						<locator>5__5 = <>s__4.Current;
						<keys>5__6 = <locator>5__5.Keys.ToList();
						if (<keys>5__6.Count == 0)
						{
							continue;
						}
						<locHandle>5__7 = Addressables.LoadResourceLocationsAsync((IList<object>)<keys>5__6, (MergeMode)1, typeof(SpawnableObject));
						<>2__current = <locHandle>5__7;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__4 = null;
					<allLocations>5__2 = (from l in <allLocations>5__2
						group l by l.InternalId into g
						select g.First()).ToList();
					Plugin.Logger.LogInfo((object)$"Found {<allLocations>5__2.Count} SpawnableObject locations");
					<enemyCount>5__3 = 0;
					<>s__8 = <allLocations>5__2.GetEnumerator();
					<>1__state = -4;
					break;
				}
				if (<>s__8.MoveNext())
				{
					<location>5__9 = <>s__8.Current;
					<loadHandle>5__10 = Addressables.LoadAssetAsync<SpawnableObject>(<location>5__9);
					<>2__current = <loadHandle>5__10;
					<>1__state = 3;
					return true;
				}
				<>m__Finally2();
				<>s__8 = default(List<IResourceLocation>.Enumerator);
				Plugin.Logger.LogInfo((object)$"Loaded {<enemyCount>5__3} enemy SpawnableObjects across {enemiesByType.Count} type(s).");
				<>s__12 = enemiesByType.GetEnumerator();
				try
				{
					while (<>s__12.MoveNext())
					{
						<kvp>5__13 = <>s__12.Current;
						Plugin.Logger.LogInfo((object)$"  {<kvp>5__13.Key}: {<kvp>5__13.Value.Count} variant(s)");
						<kvp>5__13 = default(KeyValuePair<EnemyType, List<SpawnableObject>>);
					}
				}
				finally
				{
					((IDisposable)<>s__12).Dispose();
				}
				<>s__12 = default(Dictionary<EnemyType, List<SpawnableObject>>.Enumerator);
				OnLoadComplete();
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			if (<>s__4 != null)
			{
				<>s__4.Dispose();
			}
		}

		private void <>m__Finally2()
		{
			<>1__state = -1;
			((IDisposable)<>s__8).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <GetAllSpawnables>d__25 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		private AsyncOperationHandle<IResourceLocator> <initHandle>5__1;

		private List<IResourceLocation> <allLocations>5__2;

		private IEnumerator<IResourceLocator> <>s__3;

		private IResourceLocator <locator>5__4;

		private List<object> <keys>5__5;

		private AsyncOperationHandle<IList<IResourceLocation>> <locHandle>5__6;

		private List<IResourceLocation>.Enumerator <>s__7;

		private IResourceLocation <location>5__8;

		private AsyncOperationHandle<WeaponDescriptor> <loadHandle>5__9;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <GetAllSpawnables>d__25(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			case -3:
			case 2:
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
				break;
			case -4:
			case 3:
				try
				{
				}
				finally
				{
					<>m__Finally2();
				}
				break;
			}
			<initHandle>5__1 = default(AsyncOperationHandle<IResourceLocator>);
			<allLocations>5__2 = null;
			<>s__3 = null;
			<locator>5__4 = null;
			<keys>5__5 = null;
			<locHandle>5__6 = default(AsyncOperationHandle<IList<IResourceLocation>>);
			<>s__7 = default(List<IResourceLocation>.Enumerator);
			<location>5__8 = null;
			<loadHandle>5__9 = default(AsyncOperationHandle<WeaponDescriptor>);
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_003d: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Invalid comparison between Unknown and I4
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Invalid comparison between Unknown and I4
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<initHandle>5__1 = Addressables.InitializeAsync();
					<>2__current = <initHandle>5__1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<allLocations>5__2 = new List<IResourceLocation>();
					<>s__3 = Addressables.ResourceLocators.GetEnumerator();
					<>1__state = -3;
					goto IL_0168;
				case 2:
					<>1__state = -3;
					if ((int)<locHandle>5__6.Status == 1)
					{
						<allLocations>5__2.AddRange(<locHandle>5__6.Result);
					}
					Addressables.Release<IList<IResourceLocation>>(<locHandle>5__6);
					<keys>5__5 = null;
					<locHandle>5__6 = default(AsyncOperationHandle<IList<IResourceLocation>>);
					<locator>5__4 = null;
					goto IL_0168;
				case 3:
					{
						<>1__state = -4;
						if ((int)<loadHandle>5__9.Status == 1)
						{
							descriptors.Add(<loadHandle>5__9.Result);
						}
						<loadHandle>5__9 = default(AsyncOperationHandle<WeaponDescriptor>);
						<location>5__8 = null;
						break;
					}
					IL_0168:
					while (<>s__3.MoveNext())
					{
						<locator>5__4 = <>s__3.Current;
						<keys>5__5 = <locator>5__4.Keys.ToList();
						if (<keys>5__5.Count == 0)
						{
							continue;
						}
						<locHandle>5__6 = Addressables.LoadResourceLocationsAsync((IList<object>)<keys>5__5, (MergeMode)1, typeof(WeaponDescriptor));
						<>2__current = <locHandle>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__3 = null;
					<allLocations>5__2 = (from l in <allLocations>5__2
						group l by l.InternalId into g
						select g.First()).ToList();
					Plugin.Logger.LogInfo((object)$"Found {<allLocations>5__2.Count} WeaponDescriptor locations");
					<>s__7 = <allLocations>5__2.GetEnumerator();
					<>1__state = -4;
					break;
				}
				if (<>s__7.MoveNext())
				{
					<location>5__8 = <>s__7.Current;
					<loadHandle>5__9 = Addressables.LoadAssetAsync<WeaponDescriptor>(<location>5__8);
					<>2__current = <loadHandle>5__9;
					<>1__state = 3;
					return true;
				}
				<>m__Finally2();
				<>s__7 = default(List<IResourceLocation>.Enumerator);
				OnLoadComplete();
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			if (<>s__3 != null)
			{
				<>s__3.Dispose();
			}
		}

		private void <>m__Finally2()
		{
			<>1__state = -1;
			((IDisposable)<>s__7).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public static List<WeaponDescriptor> descriptors = new List<WeaponDescriptor>();

	public static Material weaponMat;

	public static GameObject Agony;

	public static GameObject Tundra;

	public static GameObject MirrorReaper;

	public static GameObject VirtueBeam;

	public static GameObject BreakParticle;

	public static Dictionary<EnemyType, List<SpawnableObject>> enemiesByType = new Dictionary<EnemyType, List<SpawnableObject>>();

	private static int _loadsDone = 0;

	private const int TotalLoads = 2;

	public static GameObject napalmProj;

	public static GameObject mindflayerBeam;

	public static GameObject funnyPowerIntroSpawn;

	public static GameObject zapThingy;

	public static GameObject spawnEffect;

	public static AudioClip StalkerWarning;

	public static Sprite ArmFeedbacker;

	public static Sprite ArmKnuckleBlaster;

	public static Sprite ArmWhiplash;

	public static bool IsReady { get; private set; } = false;


	public static void Init()
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: 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_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_021a: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		((MonoBehaviour)Plugin.Instance).StartCoroutine(GetAllSpawnables());
		((MonoBehaviour)Plugin.Instance).StartCoroutine(GetAllEnemies());
		if ((Object)(object)napalmProj == (Object)null)
		{
			napalmProj = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Prefabs/Attacks and Projectiles/GasolineProjectile.prefab").WaitForCompletion();
		}
		if ((Object)(object)VirtueBeam == (Object)null)
		{
			VirtueBeam = Addressables.LoadAssetAsync<GameObject>((object)"Virtue Insignia").WaitForCompletion();
		}
		if ((Object)(object)BreakParticle == (Object)null)
		{
			BreakParticle = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Particles/Breaks/BreakParticle.prefab").WaitForCompletion();
		}
		if ((Object)(object)Agony == (Object)null)
		{
			Agony = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Prefabs/Enemies/SwordsMachine Agony.prefab").WaitForCompletion();
		}
		if ((Object)(object)funnyPowerIntroSpawn == (Object)null)
		{
			funnyPowerIntroSpawn = Addressables.LoadAssetAsync<EndlessEnemy>((object)"Assets/Data/Cyber Grind Patterns/Data/PowerEndlessData.asset").WaitForCompletion().prefab;
		}
		if ((Object)(object)Tundra == (Object)null)
		{
			Tundra = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Prefabs/Enemies/SwordsMachine Tundra.prefab").WaitForCompletion();
		}
		if ((Object)(object)zapThingy == (Object)null)
		{
			zapThingy = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Particles/HitSparkElectricity.prefab").WaitForCompletion();
		}
		if ((Object)(object)spawnEffect == (Object)null)
		{
			spawnEffect = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Particles/Spawn Effects/SpawnEffect Melee Hard.prefab").WaitForCompletion();
		}
		if ((Object)(object)mindflayerBeam == (Object)null)
		{
			mindflayerBeam = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Mindflayer Beam.prefab").WaitForCompletion();
		}
		if ((Object)(object)StalkerWarning == (Object)null)
		{
			StalkerWarning = Addressables.LoadAssetAsync<AudioClip>((object)"Assets/Sounds/Enemies/StalkerWarning.wav").WaitForCompletion();
		}
		if ((Object)(object)ArmFeedbacker == (Object)null)
		{
			ArmFeedbacker = Addressables.LoadAssetAsync<Sprite>((object)"Assets/Textures/UI/ArmFeedbacker.png").WaitForCompletion();
		}
		if ((Object)(object)ArmKnuckleBlaster == (Object)null)
		{
			ArmKnuckleBlaster = Addressables.LoadAssetAsync<Sprite>((object)"Assets/Textures/UI/ArmKnuckleblaster.png").WaitForCompletion();
		}
		if ((Object)(object)ArmWhiplash == (Object)null)
		{
			ArmWhiplash = Addressables.LoadAssetAsync<Sprite>((object)"Assets/Textures/UI/ArmWhiplash.png").WaitForCompletion();
		}
	}

	private static void OnLoadComplete()
	{
		_loadsDone++;
		if (_loadsDone >= 2)
		{
			IsReady = true;
			Plugin.Logger.LogInfo((object)($"AssetsManager ready — {descriptors.Count} weapon descriptors, " + $"{enemiesByType.Values.Sum((List<SpawnableObject> l) => l.Count)} enemies across " + $"{enemiesByType.Count} type(s) loaded."));
		}
	}

	[IteratorStateMachine(typeof(<GetAllSpawnables>d__25))]
	private static IEnumerator GetAllSpawnables()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <GetAllSpawnables>d__25(0);
	}

	[IteratorStateMachine(typeof(<GetAllEnemies>d__26))]
	private static IEnumerator GetAllEnemies()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <GetAllEnemies>d__26(0);
	}

	public static Sprite prefToDescriptor(string pref, bool alternate)
	{
		if (!IsReady)
		{
			Plugin.Logger.LogWarning((object)("prefToDescriptor called before assets finished loading! pref=" + pref));
			return null;
		}
		char c = pref.Last();
		if (pref.Contains("rev"))
		{
			IEnumerable<WeaponDescriptor> source = descriptors.Where((WeaponDescriptor x) => x.weaponName.StartsWith((!alternate) ? "Revolver" : "Alternative Revolver"));
			switch (c)
			{
			case '0':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Pierce"))).icon;
			case '1':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Twirl"))).icon;
			case '2':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Ricochet"))).icon;
			}
		}
		else if (pref.Contains("sho"))
		{
			IEnumerable<WeaponDescriptor> source = descriptors.Where((WeaponDescriptor x) => x.weaponName.StartsWith((!alternate) ? "Shotgun" : "Hammer"));
			switch (c)
			{
			case '0':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Grenade"))).icon;
			case '1':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Pump"))).icon;
			case '2':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Saw"))).icon;
			}
		}
		else if (pref.Contains("nai"))
		{
			IEnumerable<WeaponDescriptor> source = descriptors.Where((WeaponDescriptor x) => x.weaponName.StartsWith((!alternate) ? "Nailgun" : "Sawblade Launcher"));
			switch (c)
			{
			case '0':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Magnet"))).icon;
			case '1':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Overheat"))).icon;
			case '2':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Jumpstart"))).icon;
			}
		}
		else if (pref.Contains("rai"))
		{
			IEnumerable<WeaponDescriptor> source = descriptors.Where((WeaponDescriptor x) => x.weaponName.StartsWith("Railcannon"));
			switch (c)
			{
			case '0':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Electric"))).icon;
			case '1':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Harpoon"))).icon;
			case '2':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Malicious"))).icon;
			}
		}
		else if (pref.Contains("rock"))
		{
			IEnumerable<WeaponDescriptor> source = descriptors.Where((WeaponDescriptor x) => x.weaponName.StartsWith("Rocket Launcher"));
			switch (c)
			{
			case '0':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Freeze"))).icon;
			case '1':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Cannonball"))).icon;
			case '2':
				return source.FirstOrDefault((Func<WeaponDescriptor, bool>)((WeaponDescriptor x) => x.weaponName.EndsWith("Napalm"))).icon;
			}
		}
		else if (pref.Contains("arm"))
		{
			switch (c)
			{
			case '0':
				return ArmFeedbacker;
			case '1':
				return ArmKnuckleBlaster;
			case '2':
				return ArmWhiplash;
			}
		}
		Plugin.Logger.LogWarning((object)("prefToDescriptor: no match for pref='" + pref + "'"));
		return descriptors.Find((WeaponDescriptor x) => x.weaponName == "UNKNOWN").icon;
	}

	public static List<SpawnableObject> GetEnemiesOfType(EnemyType type)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		if (!IsReady)
		{
			Plugin.Logger.LogWarning((object)"GetEnemiesOfType called before assets finished loading!");
			return null;
		}
		List<SpawnableObject> value;
		return enemiesByType.TryGetValue(type, out value) ? value : new List<SpawnableObject>();
	}
}
public class Missle : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <ActivateHoming>d__12 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Missle <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ActivateHoming>d__12(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(<>4__this.homingDelay);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.homingActive = true;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public EnemyIdentifier enemyThatGotHit;

	private EnemyIdentifier target;

	public float speed = 25f;

	public float upwardForce = 15f;

	public float homingDelay = 0.5f;

	public float turnSpeed = 5f;

	public float damage = 10f;

	public float explosionRadius = 0.1f;

	private bool homingActive = false;

	private Rigidbody rb;

	private bool kaboomed = false;

	private void Start()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		rb = ((Component)this).GetComponent<Rigidbody>();
		rb.velocity = Vector3.up * upwardForce;
		target = enemyThatGotHit;
		((MonoBehaviour)this).StartCoroutine(ActivateHoming());
	}

	[IteratorStateMachine(typeof(<ActivateHoming>d__12))]
	private IEnumerator ActivateHoming()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ActivateHoming>d__12(0)
		{
			<>4__this = this
		};
	}

	private void FixedUpdate()
	{
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: 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_0118: Unknown result type (might be due to invalid IL or missing references)
		if (!homingActive)
		{
			return;
		}
		if ((Object)(object)target == (Object)null || target.dead)
		{
			List<EnemyIdentifier> currentEnemies = MonoSingleton<EnemyTracker>.Instance.GetCurrentEnemies();
			if (currentEnemies.Count <= 0)
			{
				return;
			}
			target = currentEnemies[Random.Range(0, currentEnemies.Count)];
		}
		Vector3 val = (((Object)(object)target.weakPoint == (Object)null) ? ((Component)target).transform.position : target.weakPoint.transform.position);
		Vector3 val2 = val - ((Component)this).transform.position;
		Vector3 normalized = ((Vector3)(ref val2)).normalized;
		Vector3 velocity = Vector3.Lerp(rb.velocity, normalized * speed, turnSpeed * Time.fixedDeltaTime);
		rb.velocity = velocity;
		Transform transform = ((Component)this).transform;
		val2 = rb.velocity;
		transform.forward = ((Vector3)(ref val2)).normalized;
	}

	private void OnTriggerEnter(Collider col)
	{
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		if (!Object.op_Implicit((Object)(object)((Component)col).gameObject.GetComponent<NewMovement>()) && LayerMaskDefaults.IsMatchingLayer(((Component)col).gameObject.layer, (LMD)3) && !kaboomed)
		{
			kaboomed = true;
			Plugin.Logger.LogInfo((object)("I hit " + ((Object)((Component)col).gameObject).name));
			EnemyIdentifierIdentifier component = ((Component)col).gameObject.GetComponent<EnemyIdentifierIdentifier>();
			EnemyIdentifier val = (((Object)(object)component == (Object)null) ? ((Component)col).gameObject.GetComponent<EnemyIdentifier>() : component.eid);
			if ((Object)(object)val != (Object)null)
			{
				val.hitter = "missle";
				val.DeliverDamage(((Component)col).gameObject, Vector3.zero, ((Component)component).transform.position, damage, false, 0f, (GameObject)null, false, false);
			}
			Explode();
		}
	}

	private void Explode()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.explosion, ((Component)this).transform.position, Quaternion.identity);
		Explosion[] componentsInChildren = val.GetComponentsInChildren<Explosion>();
		foreach (Explosion val2 in componentsInChildren)
		{
			val2.maxSize = explosionRadius;
			val2.canHit = (AffectedSubjects)2;
			val2.damage = Mathf.RoundToInt(damage) * 2;
		}
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}
}
public class ExecuteOnSceneLoadRogue : MonoBehaviour
{
	[Tooltip("Lower value ExecuteOnSceneLoad are executed first")]
	public int relativeExecutionOrder = 0;

	public UnityEvent onSceneLoad;

	public void Execute()
	{
		if (onSceneLoad != null)
		{
			onSceneLoad.Invoke();
		}
	}
}
[Serializable]
public class LayerInfoRogue
{
	public string layerName = "";

	public string[] layerLevels = new string[0];
}
public class FirstRoomSpawnerRogue : MonoBehaviour, ISerializationCallbackReceiver
{
	[HideInInspector]
	internal class PlayerForcedMovement : MonoBehaviour
	{
		public NewMovement player;

		private Rigidbody rb;

		public static float defaultMoveForce = 67f;

		public float force = defaultMoveForce;

		public void Awake()
		{
			if ((Object)(object)player == (Object)null)
			{
				player = MonoSingleton<NewMovement>.Instance;
			}
			rb = ((Component)player).GetComponent<Rigidbody>();
			rb.useGravity = false;
		}

		public void LateUpdate()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			rb.velocity = new Vector3(0f, force, 0f);
		}

		public void DestroyComp()
		{
			rb.useGravity = true;
			Object.Destroy((Object)(object)this);
		}
	}

	[HideInInspector]
	private class LocalMoveTowards : MonoBehaviour
	{
		public Vector3 targetLocalPosition;

		public bool active = false;

		public float speed = 10f;

		public void Update()
		{
			//IL_001c: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (active)
			{
				((Component)this).transform.localPosition = Vector3.MoveTowards(((Component)this).transform.localPosition, targetLocalPosition, Time.deltaTime * speed);
				if (((Component)this).transform.localPosition == targetLocalPosition)
				{
					Object.Destroy((Object)(object)this);
				}
			}
		}

		public void Activate()
		{
			active = true;
		}
	}

	[HideInInspector]
	private class CustomHellmapCursor : MonoBehaviour
	{
		public Vector2 targetPosition;

		public Image targetImage;

		public AudioSource aud;

		private bool white = true;

		private RectTransform rect;

		private void Start()
		{
			rect = ((Component)this).GetComponent<RectTransform>();
			((MonoBehaviour)this).Invoke("FlashImage", 0.075f);
		}

		private void Update()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			rect.anchoredPosition = Vector2.MoveTowards(rect.anchoredPosition, targetPosition, Time.deltaTime * 4f * Vector3.Distance(Vector2.op_Implicit(rect.anchoredPosition), Vector2.op_Implicit(targetPosition)));
		}

		private void FlashImage()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (white)
			{
				white = false;
				((Graphic)targetImage).color = new Color(0f, 0f, 0f, 0f);
				if (!((Component)this).gameObject.activeSelf)
				{
					return;
				}
				aud.Play();
			}
			else
			{
				white = true;
				((Graphic)targetImage).color = Color.white;
			}
			if (((Component)this).gameObject.activeInHierarchy)
			{
				((MonoBehaviour)this).Invoke("FlashImage", 0.075f);
			}
		}
	}

	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		public static readonly <>c <>9 = new <>c();

		public static UnityAction <>9__36_5;

		public static Func<GameObject, Transform> <>9__37_1;

		public static Func<GameObject, OnLevelStart> <>9__37_2;

		public static Func<GameObject, bool> <>9__37_4;

		internal void <ConvertToAscendingFirstRoom>b__36_5()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			MonoSingleton<StatsManager>.Instance.spawnPos = ((Component)MonoSingleton<NewMovement>.Instance).transform.position;
		}

		internal Transform <Spawn>b__37_1(GameObject go)
		{
			return go.transform;
		}

		internal OnLevelStart <Spawn>b__37_2(GameObject go)
		{
			return go.GetComponent<OnLevelStart>();
		}

		internal bool <Spawn>b__37_4(GameObject o)
		{
			return ((Object)o).name == "Canvas";
		}
	}

	[Tooltip("Player will be moved to this position if the room is not ascending variant. If null, default position is used")]
	public Transform playerSpawnPos;

	[Tooltip("If set to true, room will not be deleted. Else, it will be replaced in game")]
	public bool doNotReplace = false;

	[Header("Replace Settings")]
	[Tooltip("Enabling this field causes room to be spawned as the secret variant")]
	public bool secretRoom = false;

	[Tooltip("Enabling this field causes room to be spawned as the prime variant")]
	public bool primeRoom = false;

	[Tooltip("Enabling this field causes room to be spawned as the encore variant")]
	public bool encoreRoom = false;

	[HideInInspector]
	[Tooltip("Enabling this field causes the whole room to be converted into the ascending variant where the player is spawned at the bottom and ascends upwards instead of falling")]
	public bool convertToUpwardRoom = false;

	[HideInInspector]
	[Tooltip("This clip will be played when the trap door closes beneath the player for ascending rooms")]
	public AudioClip upwardRoomDoorCloseClip;

	[HideInInspector]
	[Tooltip("If bottom part of the ascending room collides with out of bounds triggers, this list can temporarely disable them while the player is ascending")]
	public List<GameObject> upwardRoomOutOfBoundsToDisable;

	[Header("Player Fields")]
	[Space(10f)]
	public CameraClearFlags cameraFillMode = (CameraClearFlags)2;

	public Color backgroundColor = Color.black;

	[Header("Level Fields")]
	[Space(10f)]
	[Tooltip("If set to true, level title will be displayed when the door is opened")]
	public bool displayLevelTitle = true;

	[Tooltip("If set to true, music will start when the door is opened")]
	public bool startMusic = true;

	[Header("Hellmap")]
	[Tooltip("Enable the layer and level map when the player spawn")]
	[Space(10f)]
	public bool enableHellMap = false;

	[Tooltip("Sound clip which is played for each beep while falling")]
	public AudioClip hellmapBeepClip;

	[Tooltip("Each layer has a layer name and number of levels. For limbo the header is LIMBO and levels are [1-1, 1-2, 1-3, 1-4]")]
	public List<LayerInfoRogue> layersAndLevels = new List<LayerInfoRogue>();

	[HideInInspector]
	public List<int> levelSizes = new List<int>();

	[HideInInspector]
	public List<string> layerNames = new List<string>();

	[HideInInspector]
	public List<string> levelNames = new List<string>();

	[Tooltip("Which layer the cursor starts from. First layer is 0 and at the top")]
	public int layerIndexToStartFrom;

	[Tooltip("Which level in the layer the cursor starts from. The first level is 0 and is just below the layer title (the uppermost level)")]
	public int levelIndexToStartFrom;

	[Tooltip("Which layer the cursor ends at. First layer is 0 and at the top")]
	public int layerIndexToEndAt;

	[Tooltip("Which level in the layer the cursor ends at. The first level is 0 and is just below the layer title (the uppermost level)")]
	public int levelIndexToEndAt;

	private bool spawned = false;

	public static float upDisablePos = 60f;

	public static float doorClosePos = 10f;

	public static float doorCloseSpeed = 10f;

	public static float actDelay = 0.5f;

	public static float ascendingPlayerSpawnPos = -55f;

	public void OnBeforeSerialize()
	{
		levelSizes.Clear();
		layerNames.Clear();
		levelNames.Clear();
		for (int i = 0; i < layersAndLevels.Count; i++)
		{
			layerNames.Add(layersAndLevels[i].layerName);
			levelSizes.Add(layersAndLevels[i].layerLevels.Length);
			levelNames.AddRange(layersAndLevels[i].layerLevels);
		}
	}

	public void Deserialize()
	{
		layersAndLevels.Clear();
		int num = 0;
		for (int i = 0; i < levelSizes.Count; i++)
		{
			LayerInfoRogue layerInfoRogue = new LayerInfoRogue();
			layerInfoRogue.layerName = layerNames[i];
			int num2 = levelSizes[i];
			layerInfoRogue.layerLevels = new string[num2];
			for (int j = 0; j < num2; j++)
			{
				layerInfoRogue.layerLevels[j] = levelNames[num++];
			}
			layersAndLevels.Add(layerInfoRogue);
		}
	}

	public void OnAfterDeserialize()
	{
	}

	private static Text MakeText(Transform parent)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Expected O, but got Unknown
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject();
		RectTransform val2 = val.AddComponent<RectTransform>();
		((Transform)val2).SetParent(parent);
		val.transform.localScale = Vector3.one;
		return val.AddComponent<Text>();
	}

	private static RectTransform MakeRect(Transform parent)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Expected O, but got Unknown
		GameObject val = new GameObject();
		RectTransform val2 = val.AddComponent<RectTransform>();
		((Transform)val2).SetParent(parent);
		return val2;
	}

	public static void ConvertToAscendingFirstRoom(GameObject firstRoom, AudioClip doorCloseAud, List<GameObject> toEnable, List<GameObject> toDisable, bool doNotReplace)
	{
		//IL_02be: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0379: Unknown result type (might be due to invalid IL or missing references)
		//IL_038f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0399: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bd: Expected O, but got Unknown
		//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0402: Unknown result type (might be due to invalid IL or missing references)
		//IL_0423: Unknown result type (might be due to invalid IL or missing references)
		//IL_0473: Unknown result type (might be due to invalid IL or missing references)
		//IL_047d: Expected O, but got Unknown
		//IL_0484: Unknown result type (might be due to invalid IL or missing references)
		//IL_048e: Expected O, but got Unknown
		//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ab: Expected O, but got Unknown
		//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b3: Expected O, but got Unknown
		//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0519: Unknown result type (might be due to invalid IL or missing references)
		//IL_0569: Unknown result type (might be due to invalid IL or missing references)
		//IL_0573: Expected O, but got Unknown
		//IL_057a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0584: Expected O, but got Unknown
		//IL_0597: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a1: Expected O, but got Unknown
		//IL_05b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_05bf: Expected O, but got Unknown
		//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_05dd: Expected O, but got Unknown
		//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0603: Expected O, but got Unknown
		//IL_060a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0614: Expected O, but got Unknown
		//IL_0627: Unknown result type (might be due to invalid IL or missing references)
		//IL_0631: Expected O, but got Unknown
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: 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_0131: 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_017e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		//IL_021d: Unknown result type (might be due to invalid IL or missing references)
		//IL_026c: Unknown result type (might be due to invalid IL or missing references)
		//IL_028d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0652: Unknown result type (might be due to invalid IL or missing references)
		//IL_0657: Unknown result type (might be due to invalid IL or missing references)
		//IL_065d: Expected O, but got Unknown
		List<GameObject> toEnable2 = toEnable;
		List<GameObject> toDisable2 = toDisable;
		Transform val = firstRoom.transform.Find("Room");
		if (!doNotReplace)
		{
			Transform val2 = val.Find("Pit (3)");
			((Component)val2).transform.localPosition = new Vector3(0f, 2f, 41.72f);
			((Component)val2).transform.localRotation = Quaternion.Euler(0f, 0f, 180f);
			Object.Destroy((Object)(object)((Component)((Component)val).transform.Find("Room/Ceiling")).gameObject);
			Transform val3 = ((Component)val).transform.Find("Room/Floor");
			GameObject gameObject = ((Component)val3.GetChild(0)).gameObject;
			GameObject val4 = Object.Instantiate<GameObject>(gameObject, val3);
			val4.transform.localPosition = new Vector3(-15f, 9.7f, 20.28f);
			val4.transform.localRotation = Quaternion.identity;
			GameObject val5 = Object.Instantiate<GameObject>(gameObject, val3);
			val5.transform.localPosition = new Vector3(5f, 9.7f, 20.28f);
			val5.transform.localRotation = Quaternion.identity;
			GameObject val6 = Object.Instantiate<GameObject>(gameObject, val3);
			val6.transform.localPosition = new Vector3(-5f, 9.7f, 0.2f);
			val6.transform.localRotation = Quaternion.Euler(0f, -90f, 0f);
			GameObject val7 = Object.Instantiate<GameObject>(gameObject, val3);
			val7.transform.localPosition = new Vector3(5f, 9.7f, 10.28f);
			val7.transform.localRotation = Quaternion.identity;
			((Renderer)val7.GetComponent<MeshRenderer>()).materials = (Material[])(object)new Material[2]
			{
				UtilsRogue.metalDec20,
				UtilsRogue.metalDec20
			};
			GameObject val8 = Object.Instantiate<GameObject>(gameObject, val3);
			val8.transform.localPosition = new Vector3(-15f, 9.7f, 10.28f);
			val8.transform.localRotation = Quaternion.identity;
			((Renderer)val8.GetComponent<MeshRenderer>()).materials = (Material[])(object)new Material[2]
			{
				UtilsRogue.metalDec20,
				UtilsRogue.metalDec20
			};
			GameObject val9 = Object.Instantiate<GameObject>(gameObject, val3);
			val9.transform.localPosition = new Vector3(-5f, -0.3f, 20.28f);
			val9.transform.localRotation = Quaternion.Euler(0f, -90f, -180f);
		}
		Transform val10 = val.Find("Decorations");
		Transform child = val10.GetChild(12);
		child.localPosition = new Vector3(-5f, 2f, 52f);
		LocalMoveTowards floorMover = ((Component)child).gameObject.AddComponent<LocalMoveTowards>();
		floorMover.targetLocalPosition = new Vector3(-5f, 2f, 42f);
		floorMover.speed = doorCloseSpeed;
		AudioSource floorTileAud = ((Component)child).gameObject.AddComponent<AudioSource>();
		floorTileAud.playOnAwake = false;
		floorTileAud.loop = false;
		floorTileAud.clip = doorCloseAud;
		PlayerActivator act = firstRoom.GetComponentsInChildren<PlayerActivator>().First();
		((Component)act).gameObject.SetActive(false);
		NewMovement instance = MonoSingleton<NewMovement>.Instance;
		((Component)instance).transform.localPosition = new Vector3(((Component)instance).transform.localPosition.x, ascendingPlayerSpawnPos, ((Component)instance).transform.localPosition.z);
		PlayerForcedMovement focedMov = ((Component)instance).gameObject.AddComponent<PlayerForcedMovement>();
		GameObject val11 = new GameObject();
		val11.transform.SetParent(((Component)act).transform.parent);
		val11.transform.localPosition = new Vector3(0f, upDisablePos, 0f);
		val11.transform.localRotation = Quaternion.identity;
		val11.transform.localScale = new Vector3(80f, 0.2f, 80f);
		val11.layer = ((Component)act).gameObject.layer;
		BoxCollider val12 = val11.AddComponent<BoxCollider>();
		((Collider)val12).isTrigger = true;
		ObjectActivator val13 = val11.AddComponent<ObjectActivator>();
		val13.dontActivateOnEnable = true;
		val13.oneTime = true;
		val13.events = new UltrakillEvent();
		val13.events.onActivate = new UnityEvent();
		val13.events.onActivate.AddListener((UnityAction)delegate
		{
			focedMov.DestroyComp();
		});
		GameObject val14 = new GameObject();
		val14.transform.SetParent(((Component)act).transform.parent);
		val14.transform.localPosition = new Vector3(0f, doorClosePos, 0f);
		val14.transform.localRotation = Quaternion.identity;
		val14.transform.localScale = new Vector3(80f, 0.2f, 80f);
		val14.layer = ((Component)act).gameObject.layer;
		BoxCollider val15 = val14.AddComponent<BoxCollider>();
		((Collider)val15).isTrigger = true;
		ObjectActivator val16 = val14.AddComponent<ObjectActivator>();
		val16.dontActivateOnEnable = true;
		val16.oneTime = true;
		val16.events = new UltrakillEvent();
		val16.events.onActivate = new UnityEvent();
		val16.events.onActivate.AddListener((UnityAction)delegate
		{
			floorMover.Activate();
		});
		val16.events.onActivate.AddListener((UnityAction)delegate
		{
			floorTileAud.Play();
		});
		val16.events.onActivate.AddListener((UnityAction)delegate
		{
			foreach (GameObject item in toEnable2)
			{
				item.SetActive(true);
			}
			foreach (GameObject item2 in toDisable2)
			{
				item2.SetActive(false);
			}
		});
		ObjectActivator val17 = val14.AddComponent<ObjectActivator>();
		val17.dontActivateOnEnable = true;
		val17.oneTime = true;
		val17.events = new UltrakillEvent();
		val17.events.onActivate = new UnityEvent();
		val17.events.onActivate.AddListener((UnityAction)delegate
		{
			((Component)act).gameObject.SetActive(true);
		});
		UnityEvent onActivate = val17.events.onActivate;
		object obj = <>c.<>9__36_5;
		if (obj == null)
		{
			UnityAction val18 = delegate
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				MonoSingleton<StatsManager>.Instance.spawnPos = ((Component)MonoSingleton<NewMovement>.Instance).transform.position;
			};
			<>c.<>9__36_5 = val18;
			obj = (object)val18;
		}
		onActivate.AddListener((UnityAction)obj);
		val17.delay = actDelay;
	}

	public void Spawn()
	{
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_023b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0240: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_0318: Unknown result type (might be due to invalid IL or missing references)
		//IL_032f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0353: Unknown result type (might be due to invalid IL or missing references)
		//IL_0358: Unknown result type (might be due to invalid IL or missing references)
		//IL_035c: Unknown result type (might be due to invalid IL or missing references)
		//IL_036b: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_041a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0428: Unknown result type (might be due to invalid IL or missing references)
		//IL_0486: Unknown result type (might be due to invalid IL or missing references)
		//IL_048b: Unknown result type (might be due to invalid IL or missing references)
		//IL_050b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0510: Unknown result type (might be due to invalid IL or missing references)
		//IL_0511: Unknown result type (might be due to invalid IL or missing references)
		//IL_0519: Unknown result type (might be due to invalid IL or missing references)
		//IL_052d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0544: Unknown result type (might be due to invalid IL or missing references)
		//IL_0551: Unknown result type (might be due to invalid IL or missing references)
		//IL_055e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0568: Unknown result type (might be due to invalid IL or missing references)
		//IL_0598: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0630: Unknown result type (might be due to invalid IL or missing references)
		//IL_0635: Unknown result type (might be due to invalid IL or missing references)
		//IL_0636: Unknown result type (might be due to invalid IL or missing references)
		//IL_063e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0652: Unknown result type (might be due to invalid IL or missing references)
		//IL_0669: Unknown result type (might be due to invalid IL or missing references)
		//IL_0676: Unknown result type (might be due to invalid IL or missing references)
		//IL_069a: Unknown result type (might be due to invalid IL or missing references)
		//IL_06e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_070c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0719: Unknown result type (might be due to invalid IL or missing references)
		//IL_0730: Unknown result type (might be due to invalid IL or missing references)
		//IL_073d: Unknown result type (might be due to invalid IL or missing references)
		//IL_074a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0df9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0dfe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e15: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b37: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b3c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b45: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b75: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b7a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b83: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bac: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bb1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bb2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bba: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bce: Unknown result type (might be due to invalid IL or missing references)
		//IL_0be5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c01: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c0e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c1b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c89: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c8b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ccb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cd5: Expected O, but got Unknown
		//IL_0786: Unknown result type (might be due to invalid IL or missing references)
		//IL_078b: Unknown result type (might be due to invalid IL or missing references)
		//IL_078c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0794: Unknown result type (might be due to invalid IL or missing references)
		//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_07b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_07c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_07e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0811: Unknown result type (might be due to invalid IL or missing references)
		//IL_0816: Unknown result type (might be due to invalid IL or missing references)
		//IL_0817: Unknown result type (might be due to invalid IL or missing references)
		//IL_081f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0833: Unknown result type (might be due to invalid IL or missing references)
		//IL_0840: Unknown result type (might be due to invalid IL or missing references)
		//IL_085c: Unknown result type (might be due to invalid IL or missing references)
		//IL_08d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_08ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_08fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0911: Unknown result type (might be due to invalid IL or missing references)
		//IL_091e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0935: Unknown result type (might be due to invalid IL or missing references)
		//IL_0942: Unknown result type (might be due to invalid IL or missing references)
		//IL_098c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0991: Unknown result type (might be due to invalid IL or missing references)
		//IL_0992: Unknown result type (might be due to invalid IL or missing references)
		//IL_099a: Unknown result type (might be due to invalid IL or missing references)
		//IL_09ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_09c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_09f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_09fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a35: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a3a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a3b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a43: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a57: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a6e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a89: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a96: Unknown result type (might be due to invalid IL or missing references)
		//IL_1025: Unknown result type (might be due to invalid IL or missing references)
		//IL_112a: Unknown result type (might be due to invalid IL or missing references)
		if (spawned)
		{
			return;
		}
		GameObject onLevelStartObj = null;
		bool flag = (Object)(object)MonoSingleton<OnLevelStart>.Instance != (Object)null;
		if (!flag)
		{
			Transform val = ((Component)this).gameObject.transform.Find("OnLevelStart");
			if ((Object)(object)val != (Object)null)
			{
				flag = (Object)(object)((Component)val).GetComponent<OnLevelStart>() != (Object)null;
				onLevelStartObj = ((Component)val).gameObject;
			}
		}
		else
		{
			onLevelStartObj = ((Component)MonoSingleton<OnLevelStart>.Instance).gameObject;
		}
		GameObject val2 = ((Component)this).gameObject;
		GameObject val3 = Addressables.LoadAssetAsync<GameObject>((object)(secretRoom ? "FirstRoom Secret" : (primeRoom ? "FirstRoom Prime" : (encoreRoom ? "Assets/Prefabs/Levels/Special Rooms/FirstRoom Encore.prefab" : "FirstRoom")))).WaitForCompletion();
		Scene activeScene;
		if (!doNotReplace)
		{
			val2 = Object.Instantiate<GameObject>(val3, ((Component)this).transform.parent);
			if (flag)
			{
				Transform? obj = val2.transform.Find("OnLevelStart");
				if (obj == null)
				{
					activeScene = SceneManager.GetActiveScene();
					obj = (from go in ((Scene)(ref activeScene)).GetRootGameObjects()
						where ((Object)go).name == "OnLevelStart" && (Object)(object)go.transform != (Object)(object)onLevelStartObj
						select go.transform).FirstOrDefault();
				}
				Transform val4 = obj;
				if ((Object)(object)val4 != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val4).gameObject);
				}
				if ((Object)(object)onLevelStartObj != (Object)null)
				{
					onLevelStartObj.transform.SetParent(val2.transform);
				}
			}
		}
		else
		{
			GameObject val5 = Object.Instantiate<GameObject>(val3, ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform.parent);
			Object.Destroy((Object)(object)((Component)val5.transform.Find("Room")).gameObject);
			if (flag)
			{
				Transform val6 = val5.transform.Find("OnLevelStart");
				if ((Object)(object)val6 != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val6).gameObject);
				}
				else
				{
					activeScene = SceneManager.GetActiveScene();
					OnLevelStart val7 = (from go in ((Scene)(ref activeScene)).GetRootGameObjects()
						select go.GetComponent<OnLevelStart>() into ls
						where (Object)(object)ls != (Object)null && (Object)(object)((Component)ls).gameObject != (Object)(object)onLevelStartObj
						select ls).FirstOrDefault();
					if ((Object)(object)val7 != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)val7).gameObject);
					}
				}
			}
		}
		MeshCollider[] componentsInChildren = val2.GetComponentsInChildren<MeshCollider>();
		MeshFilter val9 = default(MeshFilter);
		foreach (MeshCollider val8 in componentsInChildren)
		{
			if (((Component)val8).gameObject.TryGetComponent<MeshFilter>(ref val9))
			{
				val9.mesh = val8.sharedMesh;
			}
		}
		Transform transform = ((Component)MonoSingleton<NewMovement>.Instance).transform;
		((Component)transform).transform.parent = val2.transform;
		val2.transform.position = ((Component)this).transform.position;
		val2.transform.rotation = ((Component)this).transform.rotation;
		((Component)transform).transform.parent = null;
		Quaternion rotation = ((Component)this).transform.rotation;
		UtilsRogue.SetPlayerWorldRotation(Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y, 0f));
		if ((Object)(object)playerSpawnPos != (Object)null)
		{
			((Component)transform).transform.parent = ((Component)playerSpawnPos).transform.parent;
			((Component)transform).transform.localPosition = playerSpawnPos.localPosition;
			UtilsRogue.SetPlayerWorldRotation(playerSpawnPos.rotation);
			((Component)transform).transform.SetParent((Transform)null);
		}
		MonoSingleton<StatsManager>.Instance.spawnPos = ((Component)transform).transform.position;
		try
		{
			Transform val10 = val2.transform.Find("Room/FinalDoor");
			FinalDoor component = ((Component)val10).GetComponent<FinalDoor>();
			Camera main = Camera.main;
			main.backgroundColor = backgroundColor;
			main.clearFlags = cameraFillMode;
			FinalDoorOpener component2 = ((Component)val2.transform.Find("Room/FinalDoor/FinalDoorOpener")).GetComponent<FinalDoorOpener>();
			component2.startMusic = startMusic;
			FinalDoor component3 = ((Component)val2.transform.Find("Room/FinalDoor")).GetComponent<FinalDoor>();
			Transform obj2 = ((Component)MonoSingleton<NewMovement>.Instance).transform.Find("Canvas");
			if (obj2 == null)
			{
				activeScene = SceneManager.GetActiveScene();
				obj2 = (from o in ((Scene)(ref activeScene)).GetRootGameObjects()
					where ((Object)o).name == "Canvas"
					select o).First().transform;
			}
			Transform val11 = obj2;
			GameObject val12 = null;
			if (enableHellMap)
			{
				Deserialize();
				RectTransform val13 = MakeRect(val11);
				((Object)val13).name = "Hellmap";
				val12 = ((Component)val13).gameObject;
				Vector2 anchorMin = (val13.anchorMax = new Vector2(0.5f, 0.5f));
				val13.anchorMin = anchorMin;
				val13.pivot = new Vector2(0.5f, 0.5f);
				val13.sizeDelta = new Vector2(250f, 650f);
				val13.anchoredPosition = Vector2.zero;
				((Transform)val13).localScale = Vector3.one * 0.82244f;
				((Transform)val13).SetAsFirstSibling();
				RectTransform val15 = MakeRect(((Component)val13).transform);
				((Object)val15).name = "Hellmap Container";
				val15.anchorMin = Vector2.zero;
				val15.anchorMax = Vector2.one;
				val15.pivot = new Vector2(0.5f, 0.5f);
				val15.sizeDelta = Vector2.zero;
				val15.anchoredPosition = Vector2.zero;
				((Transform)val15).localScale = Vector3.one;
				float num = 0f;
				Stack<RectTransform> stack = new Stack<RectTransform>();
				foreach (LayerInfoRogue layersAndLevel in layersAndLevels)
				{
					RectTransform val16 = MakeRect((Transform)(object)val15);
					anchorMin = (val16.anchorMax = new Vector2(0f, 1f));
					val16.anchorMin = anchorMin;
					val16.sizeDelta = new Vector2(250f, 50f);
					val16.pivot = new Vector2(0f, 1f);
					((Transform)val16).localScale = Vector3.one;
					val16.anchoredPosition = new Vector2(0f, (num == 0f) ? (-3.051758E-05f) : num);
					num -= 50f;
					Text val18 = MakeText((Transform)(object)val16);
					val18.text = layersAndLevel.layerName;
					val18.fontSize = 36;
					val18.font = UtilsRogue.gameFont;
					val18.alignment = (TextAnchor)3;
					((Graphic)val18).color = Color.white;
					RectTransform component4 = ((Component)val18).GetComponent<RectTransform>();
					component4.anchorMin = Vector2.zero;
					component4.anchorMax = Vector2.one;
					component4.sizeDelta = Vector2.zero;
					component4.pivot = new Vector2(0.5f, 0.5f);
					((Transform)component4).localScale = Vector3.one;
					component4.anchoredPosition = Vector2.zero;
					string[] layerLevels = layersAndLevel.layerLevels;
					foreach (string text in layerLevels)
					{
						RectTransform val19 = MakeRect((Transform)(object)val15);
						anchorMin = (val19.anchorMax = new Vector2(0f, 1f));
						val19.anchorMin = anchorMin;
						val19.pivot = new Vector2(0f, 1f);
						((Transform)val19).localScale = Vector3.one;
						val19.anchoredPosition = new Vector2(60f, num);
						val19.sizeDelta = new Vector2(125f, 45f);
						num -= 50f;
						RectTransform val21 = MakeRect(((Component)val19).transform);
						anchorMin = (val21.anchorMax = new Vector2(0.5f, 0.5f));
						val21.anchorMin = anchorMin;
						val21.sizeDelta = new Vector2(25f, 9f);
						val21.anchoredPosition = Vector2.zero;
						((Transform)val21).localScale = new Vector3(5f, 5f, 5f);
						Image val23 = ((Component)val21).gameObject.AddComponent<Image>();
						val23.type = (Type)1;
						val23.sprite = UtilsRogue.levelPanel;
						val23.pixelsPerUnitMultiplier = 1f;
						Text val24 = MakeText(((Component)val19).transform);
						val24.text = text;
						val24.font = UtilsRogue.gameFont;
						val24.fontSize = 32;
						val24.alignment = (TextAnchor)4;
						((Graphic)val24).color = Color.black;
						RectTransform component5 = ((Component)val24).gameObject.GetComponent<RectTransform>();
						component5.anchorMin = Vector2.zero;
						component5.anchorMax = Vector2.one;
						component5.pivot = new Vector2(0.5f, 0.5f);
						component5.sizeDelta = Vector2.zero;
						component5.anchoredPosition = new Vector2(0f, 0f);
						((Transform)component5).localScale = Vector3.one;
					}
					if (layersAndLevel.layerLevels.Length != 0)
					{
						RectTransform val25 = MakeRect((Transform)(object)val15);
						anchorMin = (val25.anchorMax = new Vector2(0.5f, 1f));
						val25.anchorMin = anchorMin;
						val25.pivot = new Vector2(0.5f, 0f);
						val25.anchoredPosition = new Vector2(-95f, num + 25f);
						val25.sizeDelta = new Vector2(3f, (float)layersAndLevel.layerLevels.Length * 50f - 27.5f);
						((Transform)val25).localScale = Vector3.one;
						((Component)val25).gameObject.AddComponent<Image>();
						for (int k = 0; k < layersAndLevel.layerLevels.Length; k++)
						{
							RectTransform val27 = MakeRect((Transform)(object)val25);
							anchorMin = (val27.anchorMax = new Vector2(0.5f, 0f));
							val27.anchorMin = anchorMin;
							val27.pivot = new Vector2(0f, 0.5f);
							val27.sizeDelta = new Vector2(20f, 3f);
							val27.anchoredPosition = new Vector2(-1.5f, (float)k * 50f);
							((Transform)val27).localScale = Vector3.one;
							((Component)val27).gameObject.AddComponent<Image>();
						}
						stack.Push(val25);
					}
				}
				while (stack.Count != 0)
				{
					RectTransform val29 = stack.Pop();
					((Transform)val29).SetAsLastSibling();
				}
				Vector2 anchoredPosition = ((Component)((Transform)val15).GetChild(GetChildIndexFromLayerAndLevel(layerIndexToStartFrom, levelIndexToStartFrom))).GetComponent<RectTransform>().anchoredPosition;
				((Vector2)(ref anchoredPosition))..ctor(210f, anchoredPosition.y - 22.5f);
				Vector2 anchoredPosition2 = ((Component)((Transform)val15).GetChild(GetChildIndexFromLayerAndLevel(layerIndexToEndAt, levelIndexToEndAt))).GetComponent<RectTransform>().anchoredPosition;
				((Vector2)(ref anchoredPosition2))..ctor(210f, anchoredPosition2.y - 22.5f);
				RectTransform val30 = MakeRect((Transform)(object)val13);
				anchorMin = (val30.anchorMax = new Vector2(0f, 1f));
				val30.anchorMin = anchorMin;
				val30.pivot = new Vector2(0.5f, 0.5f);
				val30.sizeDelta = new Vector2(35f, 35f);
				((Transform)val30).rotation = Quaternion.Euler(0f, 0f, 90f);
				((Transform)val30).localScale = Vector3.one;
				val30.anchoredPosition = anchoredPosition;
				AudioSource val32 = ((Component)val30).gameObject.AddComponent<AudioSource>();
				val32.playOnAwake = false;
				val32.loop = false;
				val32.clip = hellmapBeepClip;
				val32.volume = 0.1f;
				Image val33 = ((Component)val30).gameObject.AddComponent<Image>();
				val33.sprite = UtilsRogue.hellmapArrow;
				CustomHellmapCursor customHellmapCursor = ((Component)val30).gameObject.AddComponent<CustomHellmapCursor>();
				customHellmapCursor.targetPosition = anchoredPosition2;
				customHellmapCursor.aud = val32;
				customHellmapCursor.targetImage = val33;
				ObjectActivator val34 = ((Component)UnityUtilsRogue.GetComponentInChildrenRecursive<PlayerActivator>(val2.transform)).gameObject.AddComponent<ObjectActivator>();
				val34.dontActivateOnEnable = true;
				val34.oneTime = true;
				val34.events = new UltrakillEvent();
				val34.events.toDisActivateObjects = (GameObject[])(object)new GameObject[1] { ((Component)val13).gameObject };
			}
			if (convertToUpwardRoom)
			{
				foreach (GameObject item in upwardRoomOutOfBoundsToDisable)
				{
					item.SetActive(false);
				}
				List<GameObject> list = new List<GameObject>();
				if ((Object)(object)val12 != (Object)null)
				{
					list.Add(val12);
				}
				List<GameObject> list2 = new List<GameObject>();
				list2.AddRange(upwardRoomOutOfBoundsToDisable);
				ConvertToAscendingFirstRoom(val2, upwardRoomDoorCloseClip, list2, list, doNotReplace);
			}
			if (!encoreRoom)
			{
				return;
			}
			FinalRank instance = MonoSingleton<FinalRank>.Instance;
			if (!((Object)(object)instance != (Object)null))
			{
				return;
			}
			Transform val35 = ((Component)instance).transform.Find("Extra Info");
			RectTransform val36 = default(RectTransform);
			if ((Object)(object)val35 != (Object)null && ((Component)val35).gameObject.TryGetComponent<RectTransform>(ref val36))
			{
				val36.anchoredPosition = Vector2.op_Implicit(new Vector3(0f, 200f, 0f));
				val36.sizeDelta = new Vector2(480f, 180f);
			}
			Transform val37 = ((Component)instance).transform.Find("Secrets -  Title");
			Transform val38 = ((Component)instance).transform.Find("Secrets - Info");
			Transform val39 = (((Object)(object)val38 == (Object)null) ? null : ((Component)val38).transform.Find("Text (1)"));
			Transform val40 = ((Component)instance).transform.Find("Challenge - Title");
			Transform val41 = ((Component)instance).transform.Find("Challenge");
			List<GameObject> list3 = instance.toAppear.ToList();
			if ((Object)(object)val37 != (Object)null && !list3.Contains(((Component)val37).gameObject))
			{
				list3.Insert(list3.Count - 1, ((Component)val37).gameObject);
			}
			if ((Object)(object)val38 != (Object)null && !list3.Contains(((Component)val38).gameObject))
			{
				list3.Insert(list3.Count - 1, ((Component)val38).gameObject);
			}
			if ((Object)(object)val39 != (Object)null && !list3.Contains(((Component)val39).gameObject))
			{
				list3.Insert(list3.Count - 1, ((Component)val39).gameObject);
			}
			if ((Object)(object)val40 != (Object)null && !list3.Contains(((Component)val40).gameObject))
			{
				((Component)val40).gameObject.SetActive(true);
				list3.Insert(list3.Count - 1, ((Component)val40).gameObject);
			}
			if ((Object)(object)val41 != (Object)null && !list3.Contains(((Component)val41).gameObject))
			{
				list3.Insert(list3.Count - 1, ((Component)val41).gameObject);
			}
			instance.toAppear = list3.ToArray();
			Transform val42 = ((Component)val11).transform.Find("Level Stats Controller");
			if (!((Object)(object)val42 != (Object)null))
			{
				return;
			}
			LevelStats componentInChildren = ((Component)val42).GetComponentInChildren<LevelStats>(true);
			((Component)componentInChildren).GetComponent<RectTransform>().sizeDelta = new Vector2(285f, 315f);
			Transform obj3 = ((Component)componentInChildren).transform.Find("Challenge Title/Challenge");
			componentInChildren.challenge = ((obj3 != null) ? ((Component)obj3).GetComponent<TMP_Text>() : null);
			Transform obj4 = ((Component)componentInChildren).transform.Find("Challenge Title");
			if (obj4 != null)
			{
				((Component)obj4).gameObject.SetActive(true);
			}
			Transform obj5 = ((Component)componentInChildren).transform.Find("Secrets Title");
			if (obj5 != null)
			{
				((Component)obj5).gameObject.SetActive(true);
			}
			List<Image> list4 = new List<Image>();
			for (int num2 = 5; num2 >= 1; num2--)
			{
				Transform val43 = ((Component)componentInChildren).transform.Find($"Secrets Title/Secret {num2}");
				if ((Object)(object)val43 != (Object)null)
				{
					list4.Add(((Component)val43).GetComponent<Image>());
				}
			}
			componentInChildren.secrets = list4.ToArray();
			Transform val44 = ((Component)componentInChildren).transform.Find("Assists Title");
			((Component)val44).GetComponent<RectTransform>().anchoredPosition = new Vector2(10f, -275f);
		}
		catch (Exception ex)
		{
			throw ex;
		}
		finally
		{
			spawned = true;
		}
		int GetChildIndexFromLayerAndLevel(int layer, int level)
		{
			int num3 = 0;
			for (int l = 0; l < layer; l++)
			{
				num3 += 1 + levelSizes[l];
			}
			return num3 + 1 + level;
		}
	}

	public void Awake()
	{
		Spawn();
	}

	public void Start()
	{
		if ((Object)(object)MonoSingleton<OnLevelStart>.Instance != (Object)null)
		{
			MonoSingleton<OnLevelStart>.Instance.levelNameOnStart = displayLevelTitle;
		}
		else
		{
			Debug.LogWarning((object)"Could not find OnLevelStart");
		}
		if (!doNotReplace)
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
}
public class Gambler : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <explosionNumerator>d__13 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Gambler <>4__this;

		private GameObject <explosionPrefab>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <explosionNumerator>d__13(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<explosionPrefab>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.ExplosionWarningThing.SetActive(true);
				<>2__current = (object)new WaitForSeconds(1.5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<explosionPrefab>5__1 = MonoSingleton<DefaultReferenceManager>.Instance.explosion;
				if ((Object)(object)<explosionPrefab>5__1 != (Object)null)
				{
					Object.Instantiate<GameObject>(<explosionPrefab>5__1, ((Component)<>4__this).transform.position, Quaternion.identity);
					<>4__this.zone.ForceOff();
					MonoSingleton<AudioMixerController>.Instance.SetMusicVolume(<>4__this.zone.originalMusicVolume);
				}
				Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private const float GAMBLE_COOLDOWN = 1.5f;

	private const float EXPLOSION_BASE_CHANCE = 0.08f;

	private const float EXPLOSION_CHANCE_RAMP = 0.07f;

	public GameObject ExplosionWarningThing;

	public ShopZone zone;

	private float cooldown = 0f;

	private int useCount = 0;

	private bool exploded = false;

	private Transform itemPlacementThing;

	public void Gamble()
	{
		if (!exploded)
		{
			Activate();
		}
	}

	private void Awake()
	{
		//IL_0018: 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)
		if ((Object)(object)itemPlacementThing == (Object)null)
		{
			itemPlacementThing = new GameObject("ItemPar").transform;
			((Component)itemPlacementThing).transform.parent = ((Component)this).transform.parent;
			itemPlacementThing.position = ((Component)this).transform.position;
		}
	}

	public void Activate()
	{
		RogueDifficultyManager instance = RogueDifficultyManager.Instance;
		if ((Object)(object)instance == (Object)null)
		{
			return;
		}
		if (instance.Gold <= 0)
		{
			HudMessageReceiver instance2 = MonoSingleton<HudMessageReceiver>.Instance;
			if (instance2 != null)
			{
				instance2.SendHudMessage("No gold to gamble!", "", "", 0, false, false, true);
			}
			return;
		}
		instance.Gold--;
		useCount++;
		float num = 0.08f + 0.07f * (float)(useCount - 1);
		if (RogueDifficultyManager.GambleItemRNG.NextDouble() <= (double)num)
		{
			Explode();
		}
		else if (RogueDifficultyManager.GambleItemRNG.NextDouble() <= 0.3499999940395355)
		{
			HudMessageReceiver instance3 = MonoSingleton<HudMessageReceiver>.Instance;
			if (instance3 != null)
			{
				instance3.SendHudMessage("You won!", "", "", 0, false, false, true);
			}
			ItemPickup.CreatePickup(Plugin.GiveRandomItem(RogueDifficultyManager.GambleItemRNG), itemPlacementThing, 5f);
		}
		else
		{
			HudMessageReceiver instance4 = MonoSingleton<HudMessageReceiver>.Instance;
			if (instance4 != null)
			{
				instance4.SendHudMessage("You lost... try again?", "", "", 0, false, false, true);
			}
		}
	}

	private void Explode()
	{
		exploded = true;
		((MonoBehaviour)this).StartCoroutine(explosionNumerator());
	}

	[IteratorStateMachine(typeof(<explosionNumerator>d__13))]
	private IEnumerator explosionNumerator()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <explosionNumerator>d__13(0)
		{
			<>4__this = this
		};
	}
}
public class GoldPickup : MonoBehaviour
{
	private bool pickedUp = false;

	private void Update()
	{
		//IL_000b: 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)
		if (Vector3.Distance(((Component)MonoSingleton<NewMovement>.Instance).transform.position, ((Component)this).transform.position) <= 2f && !pickedUp)
		{
			pickedUp = true;
			RogueDifficultyManager.Instance.Gold++;
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}

	public static void CreatePickup(Vector3 position)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: 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)
		GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
		val.GetComponent<Collider>().enabled = false;
		val.AddComponent<GoldPickup>();
		val.transform.position = position + Vector3.up * 2f;
	}
}
public class ItemPedestal : MonoBehaviour
{
	private BaseItem chosenItem;

	private void Start()
	{
		if ((float)RogueDifficultyManager.ItemRNG.NextDouble() <= 0.5f)
		{
			chosenItem = Plugin.GiveRandomItem();
			ItemPickup.CreatePickup(chosenItem, ((Component)this).transform);
		}
		else
		{
			WeaponPickupRogue.CreatePickup(((Component)this).transform);
		}
	}
}
public class ItemPickup : MonoBehaviour
{
	public BaseItem item;

	private bool pickedUp = false;

	private Func<bool> canPickup;

	private void Update()
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		((Component)((Component)this).transform).transform.LookAt(((Component)Camera.main).transform);
		((Component)((Component)this).transform).transform.Rotate(0f, 180f, 0f);
		if (Vector3.Distance(((Component)MonoSingleton<NewMovement>.Instance).transform.position, ((Component)this).transform.position) <= 2f && !pickedUp && (canPickup == null || canPickup()))
		{
			pickedUp = true;
			HudMessageReceiver instance = MonoSingleton<HudMessageReceiver>.Instance;
			if (instance != null)
			{
				instance.SendHudMessage(item.ToString(), "", "", 0, false, false, true);
			}
			Plugin.GiveItem(item);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}

	public static void CreatePickup(BaseItem item, Transform position, float offset = 3f)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Expected O, but got Unknown
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: 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)
		GameObject val = GameObject.CreatePrimitive((PrimitiveType)5);
		val.GetComponent<Collider>().enabled = false;
		val.AddComponent<ItemPickup>().item = item;
		Material val2 = new Material(AssetsManager.weaponMat);
		val2.mainTexture = (Texture)(object)item.ItemTexture;
		((Renderer)val.GetComponent<MeshRenderer>()).material = val2;
		val.transform.position = position.position + Vector3.up * offset;
		val.transform.parent = position;
		Transform transform = val.transform;
		transform.localScale *= 3f;
	}

	public static void CreatePickupConditional(BaseItem item, Transform position, Func<bool> pickupCon, float offset = 3f)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = GameObject.CreatePrimitive((PrimitiveType)5);
		val.GetComponent<Collider>().enabled = false;
		val.AddComponent<ItemPickup>().item = item;
		val.GetComponent<ItemPickup>().canPickup = pickupCon;
		Material val2 = new Material(AssetsManager.weaponMat);
		val2.mainTexture = (Texture)(object)item.ItemTexture;
		((Renderer)val.GetComponent<MeshRenderer>()).material = val2;
		val.transform.position = position.position + Vector3.up * offset;
		Transform transform = val.transform;
		transform.localScale *= 3f;
		val.transform.parent = position;
	}
}
public class MinimapUI : MonoBehaviour
{
	[Header("References")]
	public RectTransform minimapPanel;

	[Header("Layout")]
	public float cellSize = 16f;

	[Range(0.2f, 0.6f)]
	public float corridorFraction = 0.4f;

	[Header("Room Colors")]
	public Color colorNormal = new Color(0.52f, 0.52f, 0.55f);

	public Color colorStart = new Color(0.28f, 0.82f, 0.38f);

	public Color colorBoss = new Color(0.88f, 0.14f, 0.14f);

	public Color colorTreasure = new Color(0.95f, 0.78f, 0.08f);

	public Color colorShop = new Color(0.22f, 0.52f, 0.95f);

	public Color colorGambling = new Color(0.72f, 0.22f, 0.92f);

	[Header("UI Colors")]
	public Color colorSilhouette = new Color(0.28f, 0.28f, 0.3f);

	public Color colorCorridor = new Color(0.38f, 0.38f, 0.4f);

	[Header("Current Room Outline")]
	[Tooltip("Color of the pulsing outline drawn around the current room.")]
	public Color colorOutline = new Color(0.95f, 0.95f, 1f);

	[Tooltip("Extra pixels added to each side of the cell for the outline border.")]
	public float outlinePadding = 3f;

	[Header("Direction Arrow")]
	[Tooltip("Color of the direction arrow drawn on the current room.")]
	public Color colorArrow = new Color(1f, 1f, 1f, 0.92f);

	[Tooltip("Arrow size as a fraction of cellSize. 0.5 = half the cell.")]
	[Range(0.3f, 0.9f)]
	public float arrowFraction = 0.55f;

	[Tooltip("Which Transform to read the look direction from. Leave null to fall back to NewMovement.Instance's camera.")]
	public Transform lookTarget;

	[Header("Animation")]
	public float pulseSpeed = 2.8f;

	private readonly Dictionary<Vector2Int, Image> _cells = new Dictionary<Vector2Int, Image>();

	private readonly Dictionary<(Vector2Int, Vector2Int), Image> _corridors = new Dictionary<(Vector2Int, Vector2Int), Image>();

	private readonly HashSet<Vector2Int> _visited = new HashSet<Vector2Int>();

	private readonly HashSet<Vector2Int> _scouted = new HashSet<Vector2Int>();

	private Vector2Int _currentPos = new Vector2Int(int.MinValue, 0);

	private float _pulseTimer;

	private RectTransform _outlineRT;

	private Image _outlineImg;

	private RectTransform _arrowRT;

	private Image _arrowImg;

	private static readonly Vector2Int[] Dirs = (Vector2Int[])(object)new Vector2Int[4]
	{
		Vector2Int.up,
		Vector2Int.down,
		Vector2Int.left,
		Vector2Int.right
	};

	private Dictionary<Vector2Int, Room> _placedRooms;

	private Vector2Int? _manualOverridePos = null;

	public static MinimapUI Instance { get; private set; }

	private void Awake()
	{
		if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
		else
		{
			Instance = this;
		}
	}

	public void SetRoomOverride(Vector2Int? pos)
	{
		_manualOverridePos = pos;
	}

	private void Update()
	{
		//IL_005d: 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_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		if (_placedRooms == null || (Object)(object)RoomGenerator.Instance == (Object)null)
		{
			return;
		}
		NewMovement instance = MonoSingleton<NewMovement>.Instance;
		if (!((Object)(object)instance == (Object)null))
		{
			Vector2Int val = (Vector2Int)(((??)_manualOverridePos) ?? RoomGenerator.Instance.WorldToGrid(((Component)instance).transform.position));
			if (val != _currentPos)
			{
				_currentPos = val;
				MarkVisited(val);
			}
			_pulseTimer += Time.deltaTime * pulseSpeed;
			UpdateOutline();
			UpdateArrow();
		}
	}

	public void BuildMinimap(Dictionary<Vector2Int, Room> placedRooms, HashSet<(Vector2Int, Vector2Int)> validConnections)
	{
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: 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)
		//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Unknown result type (might be due to invalid IL or missing references)
		//IL_0216: Unknown result type (might be due to invalid IL or missing references)
		//IL_032f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0334: Unknown result type (might be due to invalid IL or missing references)
		//IL_0336: Unknown result type (might be due to invalid IL or missing references)
		//IL_033a: Unknown result type (might be due to invalid IL or missing references)
		//IL_033f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0341: Unknown result type (might be due to invalid IL or missing references)
		//IL_0346: Unknown result type (might be due to invalid IL or missing references)
		//IL_034e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0360: Unknown result type (might be due to invalid IL or missing references)
		//IL_036e: Unknown result type (might be due to invalid IL or missing references)
		//IL_037c: Unknown result type (might be due to invalid IL or missing references)
		//IL_038d: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_028b: Unknown result type (might be due to invalid IL or missing references)
		//IL_029d: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
		DestroyChildren();
		_cells.Clear();
		_corridors.Clear();
		_visited.Clear();
		_scouted.Clear();
		_currentPos = new Vector2Int(int.MinValue, 0);
		_placedRooms = placedRooms;
		_outlineRT = null;
		_outlineImg = null;
		_arrowRT = null;
		_arrowImg = null;
		if ((Object)(object)minimapPanel == (Object)null)
		{
			Debug.LogError((object)"[MinimapUI] minimapPanel is not assigned.");
			return;
		}
		int num = int.MaxValue;
		int num2 = int.MaxValue;
		int num3 = int.MinValue;
		int num4 = int.MinValue;
		foreach (Vector2Int key3 in placedRooms.Keys)
		{
			Vector2Int current = key3;
			if (((Vector2Int)(ref current)).x < num)
			{
				num = ((Vector2Int)(ref current)).x;
			}
			if (((Vector2Int)(ref current)).x > num3)
			{
				num3 = ((Vector2Int)(ref current)).x;
			}
			if (((Vector2Int)(ref current)).y < num2)
			{
				num2 = ((Vector2Int)(ref current)).y;
			}
			if (((Vector2Int)(ref current)).y > num4)
			{
				num4 = ((Vector2Int)(ref current)).y;
			}
		}
		float num5 = cellSize + cellSize * corridorFraction;
		float num6 = cellSize * corridorFraction;
		float num7 = num5 - cellSize;
		Vector2 val = default(Vector2);
		((Vector2)(ref val))..ctor((0f - (float)(num3 + num) / 2f) * num5, (0f - (float)(num4 + num2) / 2f) * num5);
		foreach (KeyValuePair<Vector2Int, Room> placedRoom in placedRooms)
		{
			Vector2Int key = placedRoom.Key;
			Vector2 val2 = GridToPx(key, num5) + val;
			Vector2Int[] array = (Vector2Int[])(object)new Vector2Int[2]
			{
				Vector2Int.right,
				Vector2Int.up
			};
			foreach (Vector2Int val3 in array)
			{
				if (validConnections.Contains((key, val3)))
				{
					bool flag = val3 == Vector2Int.right;
					float num8 = (flag ? num7 : num6);
					float num9 = (flag ? num6 : num7);
					float num10 = (flag ? (cellSize / 2f + num7 / 2f) : 0f);
					float num11 = (flag ? 0f : (cellSize / 2f + num7 / 2f));
					Image val4 = MakeImage($"Corr_{key}_{val3}", minimapPanel, val2 + new Vector2(num10, num11), new Vector2(num8, num9));
					((Graphic)val4).color = Color.clear;
					_corridors[(key, val3)] = val4;
				}
			}
		}
		CreateOutline();
		foreach (KeyValuePair<Vector2Int, Room> placedRoom2 in placedRooms)
		{
			Vector2Int key2 = placedRoom2.Key;
			Vector2 anchoredPos = GridToPx(key2, num5) + val;
			Image val5 = MakeImage($"Room_{key2}", minimapPanel, anchoredPos, new Vector2(cellSize, cellSize));
			((Graphic)val5).color = Color.clear;
			_cells[key2] = val5;
		}
		CreateArrow();
		MarkVisited(Vector2Int.zero);
	}

	public void ClearAndReset()
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		DestroyChildren();
		_cells.Clear();
		_corridors.Clear();
		_visited.Clear();
		_scouted.Clear();
		_placedRooms = null;
		_currentPos = new Vector2Int(int.MinValue, 0);
		_outlineRT = null;
		_outlineImg = null;
		_arrowRT = null;
		_arrowImg = null;
	}

	private void CreateOutline()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		float num = cellSize + outlinePadding * 2f;
		_outlineImg = MakeImage("CurrentOutline", minimapPanel, Vector2.zero, new Vector2(num, num));
		((Graphic)_outlineImg).color = Color.clear;
		((Graphic)_outlineImg).raycastTarget = false;
		_outlineRT = ((Component)_outlineImg).GetComponent<RectTransform>();
		((Transform)_outlineRT).SetAsLastSibling();
	}

	private void UpdateOutline()
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_outlineRT == (Object)null))
		{
			if (_cells.TryGetValue(_currentPos, out Image value))
			{
				_outlineRT.anchoredPosition = ((Component)value).GetComponent<RectTransform>().anchoredPosition;
				((Component)_outlineRT).gameObject.SetActive(true);
				float num = 0.55f + 0.45f * Mathf.Sin(_pulseTimer);
				((Graphic)_outlineImg).color = new Color(colorOutline.r, colorOutline.g, colorOutline.b, colorOutline.a * num);
			}
			else
			{
				((Component)_outlineRT).gameObject.SetActive(false);
			}
		}
	}

	private void CreateArrow()
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		float num = cellSize * arrowFraction;
		_arrowImg = MakeImage("PlayerArrow", minimapPanel, Vector2.zero, new Vector2(num, num));
		_arrowImg.sprite = BuildArrowSprite();
		((Graphic)_arrowImg).color = colorArrow;
		((Graphic)_arrowImg).raycastTarget = false;
		_arrowRT = ((Component)_arrowImg).GetComponent<RectTransform>();
		((Transform)_arrowRT).SetAsLastSibling();
	}

	private void UpdateArrow()
	{
		//IL_001a: 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)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_arrowRT == (Object)null))
		{
			if (_cells.TryGetValue(_currentPos, out Image value))
			{
				_arrowRT.anchoredPosition = ((Component)value).GetComponent<RectTransform>().anchoredPosition;
				((Component)_arrowRT).gameObject.SetActive(true);
				float lookYaw = GetLookYaw();
				((Transform)_arrowRT).localRotation = Quaternion.Euler(0f, 0f, 0f - lookYaw);
			}
			else
			{
				((Component)_arrowRT).gameObject.SetActive(false);
			}
		}
	}

	private float GetLookYaw()
	{
		//IL_0083: 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_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		Transform transform = lookTarget;
		if ((Object)(object)transform == (Object)null && (Object)(object)MonoSingleton<NewMovement>.Instance != (Object)null)
		{
			Camera componentInChildren = ((Component)MonoSingleton<NewMovement>.Instance).GetComponentInChildren<Camera>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				transform = ((Component)componentInChildren).transform;
			}
		}
		if ((Object)(object)transform == (Object)null && (Object)(object)MonoSingleton<NewMovement>.Instance != (Object)null)
		{
			transform = ((Component)MonoSingleton<NewMovement>.Instance).transform;
		}
		if ((Object)(object)transform == (Object)null)
		{
			return 0f;
		}
		Vector3 val = Vector3.ProjectOnPlane(transform.forward, Vector3.up);
		if (((Vector3)(ref val)).sqrMagnitude < 0.001f)
		{
			val = Vector3.forward;
		}
		return Vector3.SignedAngle(Vector3.forward, val, Vector3.up);
	}

	private static Sprite BuildArrowSprite()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		//IL_0192: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false);
		((Texture)val).filterMode = (FilterMode)1;
		Color clear = Color.clear;
		Color white = Color.white;
		for (int i = 0; i < 32; i++)
		{
			for (int j = 0; j < 32; j++)
			{
				val.SetPixel(j, i, clear);
			}
		}
		for (int k = 0; k < 32; k++)
		{
			float num = Mathf.InverseLerp(7.04f, 30f, (float)k);
			if (!(num < 0f))
			{
				float num2 = Mathf.Lerp(11.2f, 0f, num);
				int num3 = Mathf.RoundToInt(16f - num2);
				int num4 = Mathf.RoundToInt(16f + num2);
				for (int l = num3; l <= num4; l++)
				{
					val.SetPixel(l, k, white);
				}
			}
		}
		int num5 = Mathf.RoundToInt(11.52f);
		int num6 = Mathf.RoundToInt(20.48f);
		int num7 = Mathf.RoundToInt(1.28f);
		int num8 = Mathf.RoundToInt(8.96f);
		for (int m = num7; m <= num8; m++)
		{
			for (int n = num5; n <= num6; n++)
			{
				val.SetPixel(n, m, white);
			}
		}
		val.Apply();
		return Sprite.Create(val, new Rect(0f, 0f, 32f, 32f), new Vector2(0.5f, 0.5f));
	}

	private void MarkVisited(Vector2Int pos)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		if (_placedRooms == null)
		{
			return;
		}
		_visited.Add(pos);
		Vector2Int[] dirs = Dirs;
		foreach (Vector2Int val in dirs)
		{
			Vector2Int val2 = pos + val;
			if (_placedRooms.ContainsKey(val2))
			{
				_scouted.Add(val2);
			}
		}
		RefreshAll();
	}

	public void RevealAll()
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		foreach (KeyValuePair<Vector2Int, Room> placedRoom in _placedRooms)
		{
			MarkVisited(placedRoom.Key);
		}
	}

	private void RefreshAll()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_012d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0160: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: 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_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
		foreach (KeyValuePair<Vector2Int, Image> cell in _cells)
		{
			Vector2Int key = cell.Key;
			Image value = cell.Value;
			if (key == _currentPos)
			{
				((Graphic)value).color = (_placedRooms.TryGetValue(key, out Room value2) ? (RoomColor(value2.roomType) * 0.9f) : (colorNormal * 0.9f));
			}
			else if (_visited.Contains(key))
			{
				((Graphic)value).color = RoomColor(_placedRooms[key].roomType) * 0.9f;
			}
			else if (_scouted.Contains(key))
			{
				((Graphic)value).color = colorSilhouette;
			}
			else
			{
				((Graphic)value).color = Color.clear;
			}
		}
		foreach (KeyValuePair<(Vector2Int, Vector2Int), Image> corridor in _corridors)
		{
			Vector2Int item = corridor.Key.Item1;
			Vector2Int item2 = corridor.Key.Item2;
			Image value3 = corridor.Value;
			bool flag = _visited.Contains(item) || _scouted.Contains(item);
			bool flag2 = _visited.Contains(item + item2) || _scouted.Contains(item + item2);
			((Graphic)value3).color = ((flag && flag2) ? colorCorridor : Color.clear);
		}
	}

	private Color RoomColor(RoomType type)
	{
		//IL_0023: 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_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		if (1 == 0)
		{
		}
		Color result = (Color)(type switch
		{
			RoomType.Start => colorStart, 
			RoomType.Boss => colorBoss, 
			RoomType.Treasure => colorTreasure, 
			RoomType.Shop => colorShop, 
			RoomType.Gambling => colorGambling, 
			_ => colorNormal, 
		});
		if (1 == 0)
		{
		}
		return result;
	}

	private static Vector2 GridToPx(Vector2Int grid, float step)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		return new Vector2((float)((Vector2Int)(ref grid)).x * step, (float)((Vector2Int)(ref grid)).y * step);
	}

	private Image MakeImage(string objName, RectTransform parent, Vector2 anchoredPos, Vector2 size)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Expected O, but got Unknown
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: 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_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject(objName, new Type[2]
		{
			typeof(RectTransform),
			typeof(Image)
		});
		val.transform.SetParent((Transform)(object)parent, false);
		RectTransform component = val.GetComponent<RectTransform>();
		Vector2 val2 = default(Vector2);
		((Vector2)(ref val2))..ctor(0.5f, 0.5f);
		component.pivot = val2;
		Vector2 anchorMin = (component.anchorMax = val2);
		component.anchorMin = anchorMin;
		component.anchoredPosition = anchoredPos;
		component.sizeDelta = size;
		Image component2 = val.GetComponent<Image>();
		((Graphic)component2).raycastTarget = false;
		return component2;
	}

	private void DestroyChildren()
	{
		if (!((Object)(object)minimapPanel == (Object)null))
		{
			for (int num = ((Transform)minimapPanel).childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Transform)minimapPanel).GetChild(num)).gameObject);
			}
		}
	}
}
public class MuffleTheMusic : MonoBehaviour
{
	private void Awake()
	{
		AudioMuffleZone component = ((Component)this).GetComponent<AudioMuffleZone>();
		component.muffleTargets = new List<AudioLowPassFilter>
		{
			((Component)MonoSingleton<MusicManager>.Instance.cleanTheme).GetComponent<AudioLowPassFilter>(),
			((Component)MonoSingleton<MusicManager>.Instance.battleTheme).GetComponent<AudioLowPassFilter>(),
			((Component)MonoSingleton<MusicManager>.Instance.bossTheme).GetComponent<AudioLowPassFilter>()
		};
	}
}
[DefaultExecutionOrder(-1)]
public class RogueDifficultyManager : MonoBehaviour
{
	[SerializeField]
	private TMP_Text goldText;

	[SerializeField]
	private TMP_Text keyText;

	[SerializeField]
	private GridLayoutGroup itemParent;

	public float Difficulty;

	public int Gold;

	public int Keys;

	private float difficultyScaleMult = 1f;

	public int floor = 1;

	private Dictionary<string, int> itemCounts;

	private Dictionary<string, GameObject> itemUIObjects;

	public static Random ItemRNG;

	public static Random GambleItemRNG;

	public static Random RoomRNG;

	public static Random BossRNG;

	private bool keepOpen;

	private float doubleTap;

	private GameObject itemsUI;

	private TMP_Text statSpeedText;

	private TMP_Text statDamageText;

	private TMP_Text statAtkSpeedText;

	private TMP_Text statCooldownText;

	private TMP_Text statFloorText;

	public static RogueDifficultyManager Instance { get; private set; }

	private void Awake()
	{
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0195: Expected O, but got Unknown
		ItemRNG = new Random(Plugin.GameSeed.GetHashCode());
		GambleItemRNG = new Random(Plugin.GameSeed.GetHashCode() * 2);
		RoomRNG = new Random(Plugin.GameSeed.GetHashCode() / 2);
		BossRNG = new Random(Plugin.GameSeed.GetHashCode() ^ 2);
		Instance = this;
		Difficulty = Plugin.CurrentDifficulty;
		itemCounts = new Dictionary<string, int>();
		itemUIObjects = new Dictionary<string, GameObject>();
		itemsUI = ((Component)GameObject.Find("Items").transform.Find("Panel")).gameObject;
		itemsUI.SetActive(false);
		itemParent = itemsUI.GetComponent<GridLayoutGroup>();
		Transform val = GameObject.Find("Items").transform.Find("Stats");
		statSpeedText = ((Component)val.Find("StatSpeed/Stt")).GetComponent<TMP_Text>();
		statDamageText = ((Component)val.Find("StatDamage/Stt")).GetComponent<TMP_Text>();
		statAtkSpeedText = ((Component)val.Find("StatAtkSpeed/Stt")).GetComponent<TMP_Text>();
		statCooldownText = ((Component)val.Find("StatCooldown/Stt")).GetComponent<TMP_Text>();
		statFloorText = ((Component)val.Find("StatFloor/Stt")).GetComponent<TMP_Text>();
		foreach (KeyValuePair<BaseItem, int> item in Plugin.items)
		{
			AddItem(item.Key);
		}
		GameObject val2 = new GameObject("ItemTooltip");
		val2.transform.SetParent(GameObject.Find("Items").transform.root, false);
		val2.AddComponent<ItemTooltip>();
	}

	private void UpdateStatsUI()
	{
		if (!((Object)(object)MonoSingleton<NewMovement>.Instance == (Object)null))
		{
			float walkSpeed = MonoSingleton<NewMovement>.Instance.walkSpeed;
			float normalMoveSpeed = Plugin.Instance.normalMoveSpeed;
			float num = walkSpeed / normalMoveSpeed;
			float num2 = Plugin.AttackSpeed.CalculateChanges(1f);
			float num3 = Plugin.globalDamageMult.CalculateChanges(1f);
			float num4 = Plugin.cooldownReduction.CalculateChanges(1f);
			statSpeedText.text = $"x{num:F2}";
			statDamageText.text = $"x{num3:F2}";
			statAtkSpeedText.text = $"x{num2:F2}";
			statCooldownText.text = $"x{num4:F2}";
			statFloorText.text = $"{floor}";
		}
	}

	public void AddItem(BaseItem item)
	{
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Expected O, but got Unknown
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Expected O, but got Unknown
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
		if (item == null)
		{
			Plugin.Logger.LogError((object)"AddItem called with null item!");
			return;
		}
		if ((Object)(object)itemParent == (Object)null)
		{
			Plugin.Logger.LogError((object)"itemParent is not assigned in the Inspector!");
			return;
		}
		string itemName = item.ItemName;
		if (itemCounts.ContainsKey(itemName))
		{
			itemCounts[itemName]++;
			if (itemUIObjects.TryGetValue(itemName, out GameObject value) && (Object)(object)value != (Object)null)
			{
				TMP_Text componentInChildren = value.GetComponentInChildren<TMP_Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = $"(x{itemCounts[itemName]})";
				}
			}
			return;
		}
		itemCounts[itemName] = 1;
		GameObject val = new GameObject(itemName);
		val.transform.SetParent(((Component)itemParent).transform, false);
		Image val2 = val.AddComponent<Image>();
		if ((Object)(object)item.ItemIcon != (Object)null)
		{
			val2.sprite = item.ItemIcon;
		}
		else
		{
			Plugin.Logger.LogWarning((object)("Item '" + itemName + "' has no icon!"));
		}
		ItemHoverHandler itemHoverHandler = val.AddComponent<ItemHoverHandler>();
		itemHoverHandler.Item = item;
		GameObject val3 = new GameObject("CountLabel");
		val3.transform.SetParent(val.transform, false);
		TMP_Text val4 = (TMP_Text)(object)val3.AddComponent<TextMeshProUGUI>();
		val4.text = "";
		val4.fontSize = 14f;
		val4.alignment = (TextAlignmentOptions)1028;
		((Graphic)val4).color = Color.white;
		RectTransform component = val3.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		itemUIObjects[itemName] = val;
	}

	private void Update()
	{
		if (!keepOpen)
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Stats.WasPerformedThisFrame)
			{
				if (!keepOpen)
				{
					if (doubleTap > 0f)
					{
						keepOpen = true;
					}
					else
					{
						doubleTap = 0.5f;
					}
				}
				itemsUI.SetActive(true);
				((Component)statDamageText.transform.parent.parent).gameObject.SetActive(true);
				if ((Object)(object)MinimapUI.Instance != (Object)null)
				{
					((Component)MinimapUI.Instance.minimapPanel).gameObject.SetActive(true);
				}
			}
			else if (MonoSingleton<InputManager>.Instance.InputSource.Stats.WasCanceledThisFrame)
			{
				itemsUI.SetActive(false);
				((Component)statDamageText.transform.parent.parent).gameObject.SetActive(false);
				if ((Object)(object)MinimapUI.Instance != (Object)null)
				{
					((Component)MinimapUI.Instance.minimapPanel).gameObject.SetActive(false);
				}
			}
		}
		else if (MonoSingleton<InputManager>.Instance.InputSource.Stats.WasPerformedThisFrame)
		{
			keepOpen = false;
			itemsUI.SetActive(false);
			((Component)statDamageText.transform.parent.parent).gameObject.SetActive(false);
			if ((Object)(object)MinimapUI.Instance != (Object)null)
			{
				((Component)MinimapUI.Instance.minimapPanel).gameObject.SetActive(false);
			}
		}
		if (doubleTap > 0f)
		{
			doubleTap = Mathf.MoveTowards(doubleTap, 0f, Time.deltaTime);
		}
		Difficulty += Time.deltaTime / 180f * difficultyScaleMult;
		goldText.text = "Gold: " + Gold;
		keyText.text = "Keys: " + Keys;
		UpdateStatsUI();
	}

	public void MoveStage()
	{
		Difficulty *= 1.2f;
		Plugin.Logger.LogInfo((object)("Before: " + difficultyScaleMult));
		int currentDifficulty = Plugin.CurrentDifficulty;
		Plugin.Logger.LogInfo((object)("Difficulty pref: " + currentDifficulty));
		difficultyScaleMult *= 1.34f * (float)((currentDifficulty + 2) / 3);
		Plugin.Logger.LogInfo((object)("After: " + difficultyScaleMult));
		floor++;
		GambleItemRNG = new Random(Plugin.GameSeed.GetHashCode() * (floor + 2));
	}

	public int GetCountBeforeRadiance(EnemyType enemyType)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: 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: Invalid comparison between Unknown and I4
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Invalid comparison between Unknown and I4
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Expected I4, but got Unknown
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Invalid comparison between Unknown and I4
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Invalid comparison between Unknown and I4
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Invalid comparison between Unknown and I4
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Invalid comparison between Unknown and I4
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Invalid comparison between Unknown and I4
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Invalid comparison between Unknown and I4
		if ((int)enemyType <= 15)
		{
			switch ((int)enemyType)
			{
			default:
				if ((int)enemyType == 9)
				{
					break;
				}
				if (enemyType - 13 <= 2)
				{
					goto case 1;
				}
				goto IL_0072;
			case 3:
				return 10;
			case 1:
			case 6:
				return 5;
			case 0:
				break;
			case 2:
			case 4:
			case 5:
				goto IL_0072;
			}
			goto IL_006e;
		}
		if ((int)enemyType <= 21)
		{
			if ((int)enemyType == 20)
			{
				goto IL_006e;
			}
			if ((int)enemyType == 21)
			{
				goto IL_006a;
			}
		}
		else
		{
			if (enemyType - 33 <= 1)
			{
				goto IL_006e;
			}
			if ((int)enemyType == 39)
			{
				goto IL_006a;
			}
		}
		goto IL_0072;
		IL_006e:
		return 4;
		IL_006a:
		return 3;
		IL_0072:
		return 2;
	}

	public BossPick GetBoss()
	{
		List<BossPick> list = new List<BossPick>();
		switch (floor)
		{
		case 1:
		case 2:
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)0)[0].gameObject, 0f, 8f),
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)0)[0].gameObject, 0f, 8f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)4)[0].gameObject, 42f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)24)[0].gameObject, 0f, 18f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)7)[0].gameObject, 0f, 20f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.funnyPowerIntroSpawn, 0f, 28f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)5)[0].gameObject, 0f, 28f)
			}));
			break;
		case 3:
		case 4:
		case 5:
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)8)[0].gameObject, 0f, 30f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)16)[0].gameObject, 65f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)26)[0].gameObject, 65f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)19)[0].gameObject, 70f)
			}));
			break;
		case 6:
		case 7:
		{
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)26)[0].gameObject, 0f, 30f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)32)[0].gameObject, 0f, 25f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)28)[0].gameObject, 0f, 35f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)25)[0].gameObject, 0f, 30f)
			}));
			Enemy A = null;
			Enemy T = null;
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.Agony, 0f, 45f),
				new BossEntry(AssetsManager.Tundra, 0f, 45f)
			}, delegate(EnemyIdentifier eid)
			{
				if ((Object)(object)A == (Object)null)
				{
					A = Room.FindEnemyComponent(((Component)eid).gameObject);
				}
				else
				{
					if ((Object)(object)T == (Object)null)
					{
						T = Room.FindEnemyComponent(((Component)eid).gameObject);
					}
					A.symbiote = T;
					T.symbiote = A;
				}
			}));
			list.Add(new BossPick(new List<List<BossEntry>>
			{
				new List<BossEntry>
				{
					new BossEntry(AssetsManager.funnyPowerIntroSpawn, 0f, 0f, 0f, 0, 1)
				},
				new List<BossEntry>
				{
					new BossEntry(AssetsManager.funnyPowerIntroSpawn, 0f, 0f, 0f, 0, 1),
					new BossEntry(AssetsManager.funnyPowerIntroSpawn, 0f, 0f, 0f, 0, 1)
				}
			}));
			break;
		}
		case 8:
		case 9:
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)18)[0].gameObject, 40f, 0f, 12f, 8)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)41)[0].gameObject, 0f, 0f, 12f, 8)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)4)[0].gameObject, 80f, 0f, 50f, 8, 2, 0.5f),
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)4)[0].gameObject, 80f, 0f, 50f, 8, 2, 0.5f)
			}));
			break;
		default:
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)18)[0].gameObject, 55f, 0f, 18f, 8, 0, 0.35f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)29)[0].gameObject, 170f, 0f, 28f, 8, 0, 0.35f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)41)[0].gameObject, 0f, 45f, 18f, 8, 0, 1f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)37)[0].gameObject, 130f, 0f, 18f, 8, 0, 0.5f)
			}));
			list.Add(new BossPick(new List<BossEntry>
			{
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)4)[0].gameObject, 95f, 0f, 60f, 8, 0, 1f),
				new BossEntry(AssetsManager.GetEnemiesOfType((EnemyType)4)[0].gameObject, 95f, 0f, 60f, 8, 0, 1f)
			}));
			break;
		}
		if (list.Count == 0)
		{
			return null;
		}
		return list[Random.Range(0, list.Count)];
	}

	public bool CanSpawn(EnemyType enemy)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: 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_0077: Expected I4, but got Unknown
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Invalid comparison between Unknown and I4
		switch ((int)enemy)
		{
		default:
			if ((int)enemy != 40)
			{
				break;
			}
			goto case 26;
		case 1:
		case 3:
		case 13:
		case 14:
		case 15:
			return true;
		case 6:
			return Plugin.SelectedChar.GetType() != typeof(Streetcleaner);
		case 0:
		case 4:
		case 5:
		case 7:
			return floor >= 3;
		case 26:
			return floor >= 5;
		case 16:
			return floor >= 6;
		case 2:
		case 8:
		case 19:
		case 22:
			return false;
		case 18:
			return floor >= 8;
		case 9:
		case 10:
		case 11:
		case 12:
		case 17:
		case 20:
		case 21:
		case 23:
		case 24:
		case 25:
			break;
		}
		return floor >= 9;
	}

	public int GetCost(EnemyType enemyType)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: 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_00b3: Expected I4, but got Unknown
		return (int)enemyType switch
		{
			3 => 1, 
			13 => 2, 
			14 => 5, 
			6 => 5, 
			0 => 20, 
			7 => 25, 
			1 => 4, 
			2 => 48, 
			8 => 175, 
			22 => 200, 
			29 => 400, 
			18 => 350, 
			32 => 250, 
			16 => 325, 
			28 => 335, 
			15 => 4, 
			5 => 55, 
			19 => 75, 
			38 => 30, 
			20 => 30, 
			12 => 20, 
			33 => 45, 
			9 => 20, 
			21 => 30, 
			39 => 50, 
			34 => 40, 
			31 => 14, 
			41 => 125, 
			25 => 145, 
			26 => 55, 
			4 => 13, 
			40 => 100, 
			_ => 2147483646, 
		};
	}
}
public class BossPick
{
	public List<List<BossEntry>> waves = new List<List<BossEntry>>();

	public Action<EnemyIdentifier> onSpawn;

	public BossPick(List<List<BossEntry>> waves, Action<EnemyIdentifier> onSpawn = null)
	{
		this.waves = waves;
		this.onSpawn = onSpawn;
	}

	public BossPick(List<BossEntry> singleWave, Action<EnemyIdentifier> onSpawn = null)
	{
		waves = new List<List<BossEntry>> { singleWave };
		this.onSpawn = onSpawn;
	}
}
public class BossEntry
{
	public GameObject prefab;

	public float healthMod;

	public float healthAddition;

	public float healthPerFloorMod;

	public int startFloor;

	public int radianceBuffs;

	public float radianceBuffsPerFloor;

	public BossEntry(GameObject prefab, float healthMod = 0f, float healthAddition = 0f, float healthPerFloorMod = 0f, int startFloor = 0, int radianceBuffs = 0, float radianceBuffsPerFloor = 0f)
	{
		this.prefab = prefab;
		this.healthMod = healthMod;
		this.healthAddition = healthAddition;
		this.healthPerFloorMod = healthPerFloorMod;
		this.startFloor = startFloor;
		this.radianceBuffs = radianceBuffs;
		this.radianceBuffsPerFloor = radianceBuffsPerFloor;
	}
}
public class ItemTooltip : MonoBehaviour
{
	private GameObject panel;

	private TMP_Text nameText;

	private TMP_Text descText;

	private RectTransform rectTransform;

	public static ItemTooltip Instance { get; private set; }

	private void Awake()
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Expected O, but got Unknown
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Expected O, but got Unknown
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Expected O, but got Unknown
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Expected O, but got Unknown
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		Instance = this;
		panel = new GameObject("TooltipPanel");
		panel.transform.SetParent(((Component)this).transform, false);
		Image val = panel.AddComponent<Image>();
		((Graphic)val).color = new Color(0f, 0f, 0f, 0.85f);
		VerticalLayoutGroup val2 = panel.AddComponent<VerticalLayoutGroup>();
		((LayoutGroup)val2).padding = new RectOffset(8, 8, 6, 6);
		((HorizontalOrVerticalLayoutGroup)val2).spacing = 4f;
		((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
		ContentSizeFitter val3 = panel.AddComponent<ContentSizeFitter>();
		val3.horizontalFit = (FitMode)2;
		val3.verticalFit = (FitMode)2;
		rectTransform = panel.GetComponent<RectTransform>();
		rectTransform.pivot = new Vector2(0f, 1f);
		GameObject val4 = new GameObject("TooltipName");
		val4.transform.SetParent(panel.transform, false);
		nameText = (TMP_Text)(object)val4.AddComponent<TextMeshProUGUI>();
		nameText.fontSize = 16f;
		nameText.fontStyle = (FontStyles)1;
		((Graphic)nameText).color = Color.yellow;
		GameObject val5 = new GameObject("TooltipDesc");
		val5.transform.SetParent(panel.transform, false);
		descText = (TMP_Text)(object)val5.AddComponent<TextMeshProUGUI>();
		descText.fontSize = 13f;
		((Graphic)descText).color = Color.white;
		LayoutElement val6 = val5.AddComponent<LayoutElement>();
		val6.preferredWidth = 220f;
		Hide();
	}

	public void Show(string itemName, string description, Vector2 screenPos)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		nameText.text = itemName;
		descText.text = description;
		panel.SetActive(true);
		UpdatePosition(screenPos);
	}

	public void Hide()
	{
		panel.SetActive(false);
	}

	private void Update()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		if (panel.activeSelf)
		{
			UpdatePosition(Vector2.op_Implicit(Input.mousePosition));
		}
	}

	private void UpdatePosition(Vector2 screenPos)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: 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)
		Vector2 val = default(Vector2);
		RectTransformUtility.ScreenPointToLocalPointInRectangle(((Component)((Component)this).transform.parent).GetComponent<RectTransform>(), screenPos, (Camera)null, ref val);
		val += new Vector2(12f, -8f);
		rectTransform.anchoredPosition = val;
	}
}
public class ItemHoverHandler : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
{
	public BaseItem Item { get; set; }

	public void OnPointerEnter(PointerEventData eventData)
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		if (Item != null && !((Object)(object)ItemTooltip.Instance == (Object)null))
		{
			string description = (string.IsNullOrEmpty(Item.itemDescription) ? "No description available." : Item.itemDescription);
			ItemTooltip.Instance.Show(Item.ItemName, description, eventData.position);
		}
	}

	public void OnPointerExit(PointerEventData eventData)
	{
		ItemTooltip.Instance?.Hide();
	}
}
public class RogueFinalRank : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <InvokeRealtimeCoroutine>d__14 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public UnityAction action;

		public float seconds;

		public RogueFinalRank <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <InvokeRealtimeCoroutine>d__14(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSecondsRealtime(seconds);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (action != null)
				{
					action.Invoke();
				}
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public const string PREF_KEY = "RogueModeBest";

	public TMP_Text waveText;

	public TMP_Text killsText;

	public TMP_Text styleText;

	public TMP_Text timeText;

	public TMP_Text bestWaveText;

	public TMP_Text bestKillsText;

	public TMP_Text bestStyleText;

	public TMP_Text bestTimeText;

	public int totalPoints;

	public GameObject[] toAppear;

	private bool skipping;

	private float timeBetween = 0.25f;

	private bool countTime;

	public float savedTime;

	private float checkedSeconds;

	private float seconds;

	private float minutes;

	private bool countWaves;

	public float savedWaves;

	private float checkedWaves;

	private bool countKills;

	public int savedKills;

	private float checkedKills;

	private bool countStyle;

	public int savedStyle;

	private float checkedStyle;

	private bool flashFade;

	private Color flashColor;

	private Image flashPanel;

	private int i;

	private bool gameOver;

	private bool complete;

	private RogueSaveData previousBest;

	private bool newBest;

	private TimeController timeController;

	private OptionsManager opm;

	private bool wasPaused;

	private StatsManager sman;

	public static RogueFinalRank Instance { get; private set; }

	private void Awake()
	{
		Instance = this;
		GameObject[] array = toAppear;
		for (int i = 0; i < array.Length; i++)
		{
			array[i].SetActive(false);
		}
		((Component)this).gameObject.SetActive(false);
	}

	public RogueSaveData GetBest()
	{
		string @string = PlayerPrefs.GetString("RogueModeBest", "");
		RogueSaveData rogueSaveData = JsonConvert.DeserializeObject<RogueSaveData>(@string);
		RogueSaveData rogueSaveData2 = new RogueSaveData();
		if (rogueSaveData == null)
		{
			rogueSaveData2.datas = new List<RogueSaveDataData>();
			rogueSaveData2.BestRun = new RogueSaveDataData();
		}
		else
		{
			rogueSaveData2 = rogueSaveData;
		}
		return rogueSaveData2;
	}

	public void GameOver()
	{
		if (gameOver)
		{
			return;
		}
		((Component)this).gameObject.SetActive(true);
		if ((Object)(object)sman == (Object)null)
		{
			sman = MonoSingleton<StatsManager>.Instance;
		}
		int @int = MonoSingleton<PrefsManager>.Instance.GetInt("difficulty", 0);
		gameOver = true;
		sman.StopTimer();
		sman.HideShit();
		MonoSingleton<TimeController>.Instance.controlTimeScale = false;
		savedTime = sman.seconds;
		savedKills = sman.kills;
		savedStyle = Plugin.items.Count;
		if (savedStyle < 0)
		{
			savedStyle = 0;
		}
		ActivateNextWave val = Object.FindObjectOfType<ActivateNextWave>();
		savedWaves = RogueDifficultyManager.Instance.floor;
		previousBest = GetBest();
		bestWaveText.text = Mathf.FloorToInt((float)previousBest.BestRun.Floor) + $"\n<color=#616161><size=20>{CalculatePerc(previousBest.BestRun.Floor)}%</size></color>";
		bestKillsText.text = previousBest.BestRun.Kills.ToString() ?? "";
		bestStyleText.text = previousBest.BestRun.ItemsGotten.ToString() ?? "";
		((Component)((Component)this).transform.Find("Panel/SeedInfo/Text (1)")).GetComponent<TMP_Text>().text = Plugin.GameSeed;
		((Component)((Component)this).transform.Find("Panel/DifficultyInfo/Text (1)")).GetComponent<TMP_Text>().text = ((Plugin.CurrentDifficulty == 1) ? "Easy" : "Hard");
		int num = 0;
		float num2;
		for (num2 = previousBest.BestRun.Time; num2 >= 60f; num2 -= 60f)
		{
			num++;
		}
		bestTimeText.text = num + ":" + num2.ToString("00.000");
		if (sman.majorUsed || MonoSingleton<AssistController>.Instance.cheatsEnabled)
		{
			return;
		}
		if (savedWaves > (float)previousBest.BestRun.Floor)
		{
			NewBest();
		}
		else if (!(savedWaves < (float)previousBest.BestRun.Floor))
		{
			if (savedKills > previousBest.BestRun.Kills)
			{
				NewBest();
			}
			else if (savedKills >= previousBest.BestRun.Kills && savedStyle > previousBest.BestRun.ItemsGotten)
			{
				NewBest();
			}
		}
	}

	private void NewBest()
	{
		previousBest.BestRun.Kills = savedKills;
		previousBest.BestRun.ItemsGotten = savedStyle;
		previousBest.BestRun.Floor = (int)savedWaves;
		previousBest.BestRun.Time = savedTime;
		PlayerPrefs.SetString("RogueModeBest", JsonConvert.SerializeObject((object)previousBest));
		PlayerPrefs.Save();
		newBest = true;
	}

	private void Update()
	{
		//IL_073f: Unknown result type (might be due to invalid IL or missing references)
		//IL_047e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0494: Expected O, but got Unknown
		//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_05bf: Expected O, but got Unknown
		//IL_0314: Unknown result type (might be due to invalid IL or missing references)
		//IL_032a: Expected O, but got Unknown
		//IL_06af: Unknown result type (might be due to invalid IL or missing references)
		//IL_06c5: Expected O, but got Unknown
		if (gameOver)
		{
			if ((Object)(object)timeController == (Object)null)
			{
				timeController = MonoSingleton<TimeController>.Instance;
			}
			if (timeController.timeScale > 0f)
			{
				timeController.timeScale = Mathf.MoveTowards(timeController.timeScale, 0f, Time.unscaledDeltaTime * (timeController.timeScale + 0.01f));
				Time.timeScale = timeController.timeScale * timeController.timeScaleModifier;
				MonoSingleton<AudioMixerController>.Instance.allSound.SetFloat("allPitch", timeController.timeScale);
				if (timeController.timeScale < 0.1f)
				{
					MonoSingleton<AudioMixerController>.Instance.forceOff = true;
					MonoSingleton<AudioMixerController>.Instance.allSound.SetFloat("allVolume", MonoSingleton<AudioMixerController>.Instance.CalculateVolume(timeController.timeScale * 10f * MonoSingleton<AudioMixerController>.Instance.sfxVolume));
					MonoSingleton<AudioMixerController>.Instance.musicSound.SetFloat("allVolume", MonoSingleton<AudioMixerController>.Instance.CalculateVolume(timeController.timeScale * 10f * MonoSingleton<AudioMixerController>.Instance.musicVolume));
				}
				MonoSingleton<AudioMixerController>.Instance.musicSound.SetFloat("allPitch", timeController.timeScale);
				MonoSingleton<MusicManager>.Instance.volume = 0.5f + timeController.timeScale / 2f;
				if (timeController.timeScale <= 0f)
				{
					Appear();
					MonoSingleton<MusicManager>.Instance.forcedOff = true;
					MonoSingleton<MusicManager>.Instance.StopMusic();
				}
			}
		}
		if (countTime)
		{
			if (savedTime >= checkedSeconds)
			{
				if (savedTime > checkedSeconds)
				{
					float num = savedTime - checkedSeconds;
					checkedSeconds += Time.unscaledDeltaTime * 20f + Time.unscaledDeltaTime * num * 1.5f;
					seconds += Time.unscaledDeltaTime * 20f + Time.unscaledDeltaTime * num * 1.5f;
				}
				if (checkedSeconds >= savedTime || skipping)
				{
					checkedSeconds = savedTime;
					seconds = savedTime;
					minutes = 0f;
					while (seconds >= 60f)
					{
						seconds -= 60f;
						minutes += 1f;
					}
					countTime = false;
					((Component)timeText).GetComponent<AudioSource>().Stop();
					((MonoBehaviour)this).StartCoroutine(InvokeRealtimeCoroutine(new UnityAction(Appear), timeBetween * 2f));
				}
				if (seconds >= 60f)
				{
					seconds -= 60f;
					minutes += 1f;
				}
				timeText.text = minutes + ":" + seconds.ToString("00.000");
			}
		}
		else if (countWaves)
		{
			if (savedWaves >= checkedWaves)
			{
				if (savedWaves > checkedWaves)
				{
					checkedWaves += Time.unscaledDeltaTime * 20f + Time.unscaledDeltaTime * (savedWaves - checkedWaves) * 1.5f;
				}
				if (checkedWaves >= savedWaves || skipping)
				{
					checkedWaves = savedWaves;
					countWaves = false;
					((Component)waveText).GetComponent<AudioSource>().Stop();
					totalPoints += Mathf.FloorToInt(savedWaves) * 100;
					((MonoBehaviour)this).StartCoroutine(InvokeRealtimeCoroutine(new UnityAction(Appear), timeBetween * 2f));
				}
				waveText.text = Mathf.FloorToInt(checkedWaves) + $"\n<color=#616161><size=20>{CalculatePerc(savedWaves)}%</size></color>";
			}
		}
		else if (countKills)
		{
			if ((float)savedKills >= checkedKills)
			{
				if ((float)savedKills > checkedKills)
				{
					checkedKills += Time.unscaledDeltaTime * 20f + Time.unscaledDeltaTime * ((float)savedKills - checkedKills) * 1.5f;
				}
				if (checkedKills >= (float)savedKills || skipping)
				{
					checkedKills = savedKills;
					countKills = false;
					((Component)killsText).GetComponent<AudioSource>().Stop();
					((MonoBehaviour)this).StartCoroutine(InvokeRealtimeCoroutine(new UnityAction(Appear), timeBetween * 2f));
				}
				killsText.text = checkedKills.ToString("0");
			}
		}
		else if (countStyle && (float)savedStyle >= checkedStyle)
		{
			float num2 = checkedStyle;
			if ((float)savedStyle > checkedStyle)
			{
				checkedStyle += Time.unscaledDeltaTime * 2500f + Time.unscaledDeltaTime * ((float)savedStyle - checkedStyle) * 1.5f;
			}
			if (checkedStyle >= (float)savedStyle || skipping)
			{
				checkedStyle = savedStyle;
				countStyle = false;
				((Component)styleText).GetComponent<AudioSource>().Stop();
				((MonoBehaviour)this).StartCoroutine(InvokeRealtimeCoroutine(new UnityAction(Appear), timeBetween * 2f));
				totalPoints += savedStyle;
			}
			styleText.text = checkedStyle.ToString("0");
		}
		if (flashFade)
		{
			flashColor.a = Mathf.MoveTowards(flashColor.a, 0f, Time.unscaledDeltaTime * 0.5f);
			((Graphic)flashPanel).color = flashColor;
			if (flashColor.a <= 0f)
			{
				flashFade = false;
			}
		}
		if (gameOver)
		{
			if ((Object)(object)timeController == (Object)null)
			{
				timeController = MonoSingleton<TimeController>.Instance;
			}
			if ((Object)(object)opm == (Object)null)
			{
				opm = MonoSingleton<OptionsManager>.Instance;
			}
			if (opm.paused && !wasPaused)
			{
				wasPaused = true;
			}
			else if (!opm.paused && wasPaused)
			{
				wasPaused = false;
				MonoSingleton<AudioMixerController>.Instance.allSound.SetFloat("allPitch", 0f);
				MonoSingleton<AudioMixerController>.Instance.allSound.SetFloat("allVolume", MonoSingleton<AudioMixerController>.Instance.CalculateVolume(timeController.timeScale * 10f * MonoSingleton<AudioMixerController>.Instance.sfxVolume));
				MonoSingleton<AudioMixerController>.Instance.musicSound.SetFloat("allPitch", 0f);
				MonoSingleton<AudioMixerController>.Instance.musicSound.SetFloat("allVolume", MonoSingleton<AudioMixerController>.Instance.CalculateVolume(timeController.timeScale * 10f * MonoSingleton<AudioMixerController>.Instance.musicVolume));
			}
			if (!MonoSingleton<InputManager>.Instance.PerformingCheatMenuCombo() && (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame || MonoSingleton<InputManager>.Instance.InputSource.Jump.WasPerformedThisFrame) && complete && !opm.paused)
			{
				SceneHelper.LoadScene("Main Menu", false);
			}
			else if (timeController.timeScale <= 0f && !MonoSingleton<InputManager>.Instance.PerformingCheatMenuCombo() && (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame || MonoSingleton<InputManager>.Instance.InputSource.Jump.WasPerformedThisFrame) && !complete && !opm.paused)
			{
				skipping = true;
				timeBetween = 0.01f;
			}
		}
	}

	private int CalculatePerc(float value)
	{
		return Mathf.FloorToInt((value - (float)Mathf.FloorToInt(value)) * 100f);
	}

	private static string TruncateUsername(string value, int maxChars)
	{
		if (value.Length > maxChars)
		{
			return value.Substring(0, maxChars);
		}
		return value;
	}

	public void Appear()
	{
		//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d0: Expected O, but got Unknown
		//IL_037a: Unknown result type (might be due to invalid IL or missing references)
		//IL_038a: Expected O, but got Unknown
		//IL_0262: Unknown result type (might be due to invalid IL or missing references)
		//IL_0278: Expected O, but got Unknown
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Expected O, but got Unknown
		//IL_0345: Unknown result type (might be due to invalid IL or missing references)
		//IL_035b: Expected O, but got Unknown
		if (i < toAppear.Length)
		{
			if (skipping)
			{
				HudOpenEffect component = toAppear[i].GetComponent<HudOpenEffect>();
				if ((Object)(object)component != (Object)null)
				{
					component.skip = true;
				}
			}
			if ((Object)(object)toAppear[i] == (Object)(object)((Component)timeText).gameObject)
			{
				if (skipping)
				{
					checkedSeconds = savedTime;
					seconds = savedTime;
					minutes = 0f;
					while (seconds >= 60f)
					{
						seconds -= 60f;
						minutes += 1f;
					}
					AudioSourceExtensions.SetPlayOnAwake(((Component)timeText).GetComponent<AudioSource>(), false);
					((MonoBehaviour)this).StartCoroutine(InvokeRealtimeCoroutine(new UnityAction(Appear), timeBetween * 2f));
					timeText.text = minutes + ":" + seconds.ToString("00.000");
				}
				else
				{
					countTime = true;
				}
			}
			else if ((Object)(object)toAppear[i] == (Object)(object)((Component)killsText).gameObject)
			{
				if (skipping)
				{
					checkedKills = savedKills;
					AudioSourceExtensions.SetPlayOnAwake(((Component)killsText).GetComponent<AudioSource>(), false);
					((MonoBehaviour)this).StartCoroutine(InvokeRealtimeCoroutine(new UnityAction(Appear), timeBetween * 2f));
					killsText.text = checkedKills.ToString("0");
				}
				else
				{
					countKills = true;
				}
			}
			else if ((Object)(object)toAppear[i] == (Object)(object)((Component)waveText).gameObject)
			{
				if (skipping)
				{
					checkedWaves = savedWaves;
					AudioSourceExtensions.SetPlayOnAwake(((Component)waveText).GetComponent<AudioSource>(), false);
					((MonoBehaviour)this).StartCoroutine(InvokeRealtimeCoroutine(new UnityAction(Appear), timeBetween * 2f));
					waveText.text = Mathf.FloorToInt(savedWaves) + $"\n<color=#616161><size=20>{CalculatePerc(savedWaves)}%</size></color>";
				}
				else
				{
					countWaves = true;
				}
			}
			else if ((Object)(object)toAppear[i] == (Object)(object)((Component)styleText).gameObject)
			{
				if (skipping)
				{
					checkedStyle = savedStyle;
					styleText.text = checkedStyle.ToString("0");
					AudioSourceExtensions.SetPlayOnAwake(((Component)styleText).GetComponent<AudioSource>(), false);
					((MonoBehaviour)this).StartCoroutine(InvokeRealtimeCoroutine(new UnityAction(Appear), timeBetween * 2f));
				}
				else
				{
					countStyle = true;
				}
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(InvokeRealtimeCoroutine(new UnityAction(Appear), timeBetween));
			}
			toAppear[i].gameObject.SetActive(true);
			i++;
		}
		else
		{
			if (newBest)
			{
				GameObject gameObject = ((Component)bestWaveText.transform.parent.parent.parent.GetChild(1)).gameObject;
				FlashPanel(gameObject);
				AudioSourceExtensions.Play(gameObject.GetComponent<AudioSource>(), true);
				bestWaveText.text = waveText.text;
				bestKillsText.text = killsText.text;
				bestStyleText.text = styleText.text;
				bestTimeText.text = timeText.text;
			}
			if (!complete)
			{
				complete = true;
				GameProgressSaver.AddMoney(totalPoints);
			}
		}
	}

	public void FlashPanel(GameObject panel)
	{
		//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_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		if (flashFade)
		{
			flashColor.a = 0f;
			((Graphic)flashPanel).color = flashColor;
		}
		flashPanel = panel.GetComponent<Image>();
		flashColor = ((Graphic)flashPanel).color;
		flashColor.a = 1f;
		((Graphic)flashPanel).color = flashColor;
		flashFade = true;
	}

	[IteratorStateMachine(typeof(<InvokeRealtimeCoroutine>d__14))]
	private IEnumerator InvokeRealtimeCoroutine(UnityAction action, float seconds)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <InvokeRealtimeCoroutine>d__14(0)
		{
			<>4__this = this,
			action = action,
			seconds = seconds
		};
	}
}
public enum RoomType
{
	Normal,
	Start,
	Boss,
	Treasure,
	Shop,
	Gambling,
	Secret
}
public class Room : MonoBehaviour
{
	private readonly struct PlannedSpawn
	{
		public readonly EnemyType type;

		public readonly int radianceBuffs;

		public PlannedSpawn(EnemyType type, int radianceBuffs)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			this.type = type;
			this.radianceBuffs = radianceBuffs;
		}
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass36_0
	{
		public GameObject bossInst;

		internal void <SpawnBoss>b__1()
		{
			Object.Destroy((Object)(object)bossInst);
		}
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass54_0
	{
		public GameObject eixt;

		public Portal port;

		internal void <funnies>b__0(IPortalTraveller IP, PortalTravelDetails D)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)IP.travellerType == 1)
			{
				Object.Destroy((Object)(object)eixt);
				RoomGenerator.Instance.RegenerateRooms();
				Object.Destroy((Object)(object)((Component)port).gameObject);
			}
		}
	}

	[CompilerGenerated]
	private sealed class <SpawnBoss>d__36 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Room <>4__this;

		private int <w>5__1;

		private List<BossEntry> <currentWave>5__2;

		private List<EnemyIdentifier> <waveEnemies>5__3;

		private bool <waveAlive>5__4;

		private List<BossEntry>.Enumerator <>s__5;

		private BossEntry <bossEntry>5__6;

		private <>c__DisplayClass36_0 <>8__7;

		private Vector3 <spawnPos>5__8;

		private EnemyIdentifier <eid>5__9;

		private int <floorsForRadiance>5__10;

		private int <totalRadiance>5__11;

		private Enemy <e>5__12;

		private int <floorsActive>5__13;

		private float <totalHealth>5__14;

		private int <r>5__15;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SpawnBoss>d__36(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<currentWave>5__2 = null;
			<waveEnemies>5__3 = null;
			<>s__5 = default(List<BossEntry>.Enumerator);
			<bossEntry>5__6 = null;
			<>8__7 = null;
			<eid>5__9 = null;
			<e>5__12 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Expected O, but got Unknown
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c8: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: 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)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Invalid comparison between Unknown and I4
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Invalid comparison between Unknown and I4
			//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.CloseOffRoom();
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				isFighting = true;
				if (<>4__this.bossEnemyType == null || <>4__this.bossEnemyType.waves == null || <>4__this.bossEnemyType.waves.Count == 0)
				{
					Debug.LogError((object)"[Room] BossPick has no waves defined.");
					return false;
				}
				<w>5__1 = 0;
				goto IL_05f9;
			case 2:
				<>1__state = -1;
				<waveAlive>5__4 = <waveEnemies>5__3.Any((EnemyIdentifier e) => (Object)(object)e != (Object)null && !e.dead);
				goto IL_0587;
			case 3:
				{
					<>1__state = -1;
					goto IL_05d8;
				}
				IL_05f9:
				if (<w>5__1 < <>4__this.bossEnemyType.waves.Count)
				{
					Debug.Log((object)$"[Room] Starting Boss Wave {<w>5__1 + 1}/{<>4__this.bossEnemyType.waves.Count}");
					<currentWave>5__2 = <>4__this.bossEnemyType.waves[<w>5__1];
					<waveEnemies>5__3 = new List<EnemyIdentifier>();
					<>s__5 = <currentWave>5__2.GetEnumerator();
					try
					{
						while (<>s__5.MoveNext())
						{
							<bossEntry>5__6 = <>s__5.Current;
							<>8__7 = new <>c__DisplayClass36_0();
							if ((Object)(object)<bossEntry>5__6.prefab == (Object)null)
							{
								continue;
							}
							<spawnPos>5__8 = ((Component)<>4__this).transform.position + Vector3.up * 1f + new Vector3(Random.Range(-4f, 4f), 0f, Random.Range(-4f, 4f));
							<>8__7.bossInst = Object.Instantiate<GameObject>(<bossEntry>5__6.prefab, <spawnPos>5__8, <bossEntry>5__6.prefab.transform.rotation);
							<>8__7.bossInst.transform.parent = ((Component)<>4__this).transform;
							<eid>5__9 = <>8__7.bossInst.GetComponent<EnemyIdentifier>() ?? <>8__7.bossInst.GetComponentInChildren<EnemyIdentifier>();
							if ((Object)(object)<eid>5__9 != (Object)null)
							{
								<waveEnemies>5__3.Add(<eid>5__9);
								if (<bossEntry>5__6.healthMod != 0f || <bossEntry>5__6.healthPerFloorMod != 0f || <bossEntry>5__6.healthAddition != 0f)
								{
									<e>5__12 = FindEnemyComponent(<>8__7.bossInst);
									if (<bossEntry>5__6.healthMod == 0f)
									{
										<bossEntry>5__6.healthMod = <eid>5__9.health;
									}
									<floorsActive>5__13 = Mathf.Max(0, RogueDifficultyManager.Instance.floor - <bossEntry>5__6.startFloor);
									<totalHealth>5__14 = <bossEntry>5__6.healthMod + <bossEntry>5__6.healthAddition + <bossEntry>5__6.healthPerFloorMod * (float)<floorsActive>5__13;
									<eid>5__9.health = <totalHealth>5__14;
									<e>5__12.health = <totalHealth>5__14;
									<e>5__12.originalHealth = <totalHealth>5__14;
									<e>5__12 = null;
								}
								<floorsForRadiance>5__10 = Mathf.Max(0, RogueDifficultyManager.Instance.floor - <bossEntry>5__6.startFloor);
								<totalRadiance>5__11 = <bossEntry>5__6.radianceBuffs + Mathf.FloorToInt(<bossEntry>5__6.radianceBuffsPerFloor * (float)<floorsForRadiance>5__10);
								<r>5__15 = 0;
								while (<r>5__15 < <totalRadiance>5__11)
								{
									<eid>5__9.BuffAll();
									<r>5__15++;
								}
								if (<totalRadiance>5__11 > 0)
								{
									Debug.Log((object)$"[Room] Applied {<totalRadiance>5__11} radiance buff(s) to {<eid>5__9.enemyType}.");
								}
								<>4__this.bossEnemyType.onSpawn?.Invoke(<eid>5__9);
								if ((Object)(object)((Component)<eid>5__9).gameObject.GetComponent<BossHealthBar>() == (Object)null)
								{
									((Component)<eid>5__9).gameObject.AddComponent<BossHealthBar>();
								}
								if ((int)<eid>5__9.enemyType == 16 || (int)<eid>5__9.enemyType == 28)
								{
									<eid>5__9.onDeath.AddListener((UnityAction)delegate
									{
										Object.Destroy((Object)(object)<>8__7.bossInst);
									});
								}
							}
							<>8__7 = null;
							<eid>5__9 = null;
							<bossEntry>5__6 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__5).Dispose();
					}
					<>s__5 = default(List<BossEntry>.Enumerator);
					<waveAlive>5__4 = true;
					goto IL_0587;
				}
				<>4__this.hasSpawnedEnemies = true;
				return false;
				IL_0587:
				if (<waveAlive>5__4)
				{
					<>2__current = (object)new WaitForSeconds(0.15f);
					<>1__state = 2;
					return true;
				}
				if (<w>5__1 < <>4__this.bossEnemyType.waves.Count - 1)
				{
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 3;
					return true;
				}
				goto IL_05d8;
				IL_05d8:
				<currentWave>5__2 = null;
				<waveEnemies>5__3 = null;
				<w>5__1++;
				goto IL_05f9;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SpawnEnemies>d__33 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Room <>4__this;

		private Dictionary<EnemyType, int> <enemyCounts>5__1;

		private List<PlannedSpawn> <spawnPlan>5__2;

		private bool <useWaves>5__3;

		private BaseItem <mask>5__4;

		private int <maskCount>5__5;

		private int <waveStart>5__6;

		private EnemyType <randomEnemy>5__7;

		private int <cost>5__8;

		private int <amountCanSpawn>5__9;

		private int <amountToSpawn>5__10;

		private Dictionary<EnemyType, int>.Enumerator <>s__11;

		private KeyValuePair<EnemyType, int> <kvp>5__12;

		private EnemyType <enemyType>5__13;

		private int <totalCount>5__14;

		private int <baseC>5__15;

		private List<int> <thresholds>5__16;

		private float <t>5__17;

		private List<int> <radianceBuffCounts>5__18;

		private int <remaining>5__19;

		private int <rounded>5__20;

		private float <next>5__21;

		private int <tier>5__22;

		private int <count>5__23;

		private int <i>5__24;

		private int <i>5__25;

		private List<int>.Enumerator <>s__26;

		private int <buffs>5__27;

		private int <waveEnd>5__28;

		private int <alive>5__29;

		private int <spawnedEnemies>5__30;

		private int <localIndex>5__31;

		private PlannedSpawn <planned>5__32;

		private GameObject <enemyPrefab>5__33;

		private Transform <spawnPt>5__34;

		private Vector3 <pos>5__35;

		private GameObject <inst>5__36;

		private KeepInBoundsRoom <kibr>5__37;

		private EnemyIdentifier <eid>5__38;

		private float <delay>5__39;

		private GameObject <objectToEnable>5__40;

		private int <b>5__41;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SpawnEnemies>d__33(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<enemyCounts>5__1 = null;
			<spawnPlan>5__2 = null;
			<mask>5__4 = null;
			<>s__11 = default(Dictionary<EnemyType, int>.Enumerator);
			<thresholds>5__16 = null;
			<radianceBuffCounts>5__18 = null;
			<>s__26 = default(List<int>.Enumerator);
			<enemyPrefab>5__33 = null;
			<spawnPt>5__34 = null;
			<inst>5__36 = null;
			<kibr>5__37 = null;
			<eid>5__38 = null;
			<objectToEnable>5__40 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0784: Unknown result type (might be due to invalid IL or missing references)
			//IL_0799: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a0: Invalid comparison between Unknown and I4
			//IL_07b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c0: Invalid comparison between Unknown and I4
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_064d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Expected O, but got Unknown
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_067d: Expected O, but got Unknown
			//IL_0874: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0852: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0934: Unknown result type (might be due to invalid IL or missing references)
			//IL_093f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0910: Unknown result type (might be due to invalid IL or missing references)
			//IL_0915: Unknown result type (might be due to invalid IL or missing references)
			//IL_091f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0924: Unknown result type (might be due to invalid IL or missing references)
			//IL_0929: Unknown result type (might be due to invalid IL or missing references)
			//IL_0746: Unknown result type (might be due to invalid IL or missing references)
			//IL_0750: Expected O, but got Unknown
			//IL_09cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_09dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (<>4__this.SpawnCredits == 0)
				{
					return false;
				}
				<>4__this.CloseOffRoom();
				<>4__this.playerHealthAtFightStart = MonoSingleton<NewMovement>.Instance.hp;
				<>4__this.SpawnCredits = Mathf.RoundToInt((float)<>4__this.SpawnCredits * RogueDifficultyManager.Instance.Difficulty);
				<>4__this.SpawnCredits = Mathf.Max(<>4__this.SpawnCredits, 3);
				Plugin.Logger.LogInfo((object)$"Room has {<>4__this.SpawnCredits} spawn credits because difficulty is {RogueDifficultyManager.Instance.Difficulty}");
				isFighting = true;
				<enemyCounts>5__1 = new Dictionary<EnemyType, int>();
				while (<>4__this.SpawnCredits > 0)
				{
					<randomEnemy>5__7 = (EnemyType)<>4__this.enemyRando.Next(0, Enum.GetValues(typeof(EnemyType)).Length);
					if (!RogueDifficultyManager.Instance.CanSpawn(<randomEnemy>5__7))
					{
						continue;
					}
					<cost>5__8 = RogueDifficultyManager.Instance.GetCost(<randomEnemy>5__7);
					if (<>4__this.SpawnCredits - <cost>5__8 >= 0)
					{
						<amountCanSpawn>5__9 = Mathf.FloorToInt((float)(<>4__this.SpawnCredits / <cost>5__8));
						<amountToSpawn>5__10 = <>4__this.enemyRando.Next(1, Mathf.Max(1, (<amountCanSpawn>5__9 + 1) / 2));
						<>4__this.SpawnCredits -= <amountToSpawn>5__10 * <cost>5__8;
						if (!<enemyCounts>5__1.ContainsKey(<randomEnemy>5__7))
						{
							<enemyCounts>5__1[<randomEnemy>5__7] = 0;
						}
						<enemyCounts>5__1[<randomEnemy>5__7] += <amountToSpawn>5__10;
					}
				}
				<spawnPlan>5__2 = new List<PlannedSpawn>();
				<>s__11 = <enemyCounts>5__1.GetEnumerator();
				try
				{
					while (<>s__11.MoveNext())
					{
						<kvp>5__12 = <>s__11.Current;
						<enemyType>5__13 = <kvp>5__12.Key;
						<totalCount>5__14 = <kvp>5__12.Value;
						<baseC>5__15 = RogueDifficultyManager.Instance.GetCountBeforeRadiance(<enemyType>5__13);
						<thresholds>5__16 = new List<int>();
						<t>5__17 = <baseC>5__15;
						while (true)
						{
							<rounded>5__20 = Mathf.RoundToInt(<t>5__17);
							if (<rounded>5__20 > <totalCount>5__14)
							{
								break;
							}
							<thresholds>5__16.Add(<rounded>5__20);
							<next>5__21 = <t>5__17 * Mathf.Sqrt(<t>5__17);
							if (<next>5__21 <= <t>5__17)
							{
								break;
							}
							<t>5__17 = <next>5__21;
						}
						<radianceBuffCounts>5__18 = new List<int>();
						<remaining>5__19 = <totalCount>5__14;
						<tier>5__22 = <thresholds>5__16.Count - 1;
						while (<tier>5__22 >= 0)
						{
							<count>5__23 = <remaining>5__19 / <thresholds>5__16[<tier>5__22];
							<remaining>5__19 %= <thresholds>5__16[<tier>5__22];
							<i>5__24 = 0;
							while (<i>5__24 < <count>5__23)
							{
								<radianceBuffCounts>5__18.Add(<tier>5__22 + 1);
								<i>5__24++;
							}
							<tier>5__22--;
						}
						<i>5__25 = 0;
						while (<i>5__25 < <remaining>5__19)
						{
							<spawnPlan>5__2.Add(new PlannedSpawn(<enemyType>5__13, 0));
							<i>5__25++;
						}
						<>s__26 = <radianceBuffCounts>5__18.GetEnumerator();
						try
						{
							while (<>s__26.MoveNext())
							{
								<buffs>5__27 = <>s__26.Current;
								<spawnPlan>5__2.Add(new PlannedSpawn(<enemyType>5__13, <buffs>5__27));
							}
						}
						finally
						{
							((IDisposable)<>s__26).Dispose();
						}
						<>s__26 = default(List<int>.Enumerator);
						<thresholds>5__16 = null;
						<radianceBuffCounts>5__18 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__11).Dispose();
				}
				<>s__11 = default(Dictionary<EnemyType, int>.Enumerator);
				Plugin.Logger.LogInfo((object)$"[Room] Spawn plan built: {<spawnPlan>5__2.Count} enemies total.");
				<useWaves>5__3 = <spawnPlan>5__2.Count >= 28;
				if (<useWaves>5__3)
				{
					Plugin.Logger.LogInfo((object)$"[Room] Large room ({<spawnPlan>5__2.Count} enemies) — using wave-based spawning.");
				}
				<mask>5__4 = Plugin.getItem("Agonized Mask");
				<maskCount>5__5 = Plugin.GetItemCount(<mask>5__4);
				<waveStart>5__6 = 0;
				goto IL_0b54;
			case 1:
				<>1__state = -1;
				goto IL_0668;
			case 2:
				<>1__state = -1;
				Plugin.Logger.LogInfo((object)$"[Room] Spawning next wave (index {<waveStart>5__6}).");
				goto IL_06ae;
			case 3:
				{
					<>1__state = -1;
					goto IL_0761;
				}
				IL_0668:
				<alive>5__29 = ((Component)<>4__this).GetComponentsInChildren<EnemyIdentifier>().Count((EnemyIdentifier e) => !e.dead);
				if (<alive>5__29 > 8)
				{
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
				IL_0b54:
				if (<waveStart>5__6 < <spawnPlan>5__2.Count)
				{
					if (<useWaves>5__3 && <waveStart>5__6 > 0)
					{
						Plugin.Logger.LogInfo((object)$"[Room] Waiting to spawn wave starting at index {<waveStart>5__6}…");
						goto IL_0668;
					}
					goto IL_06ae;
				}
				if (<>4__this._activatorsWereUsed)
				{
					<>4__this._activatorSettleUntil = Time.time + 6f;
				}
				<>4__this.hasSpawnedEnemies = true;
				return false;
				IL_0b30:
				if (<spawnedEnemies>5__30 < <waveEnd>5__28)
				{
					<localIndex>5__31 = <spawnedEnemies>5__30 - <waveStart>5__6;
					if (<localIndex>5__31 < 100)
					{
						<delay>5__39 = ((<localIndex>5__31 < 25) ? 0.05f : (0.05f / (float)(<localIndex>5__31 - 24)));
						<>2__current = (object)new WaitForSeconds(<delay>5__39);
						<>1__state = 3;
						return true;
					}
					goto IL_0761;
				}
				<waveStart>5__6 = <waveEnd>5__28;
				goto IL_0b54;
				IL_06ae:
				<waveEnd>5__28 = (<useWaves>5__3 ? Mathf.Min(<waveStart>5__6 + 12, <spawnPlan>5__2.Count) : <spawnPlan>5__2.Count);
				<spawnedEnemies>5__30 = <waveStart>5__6;
				goto IL_0b30;
				IL_0761:
				<planned>5__32 = <spawnPlan>5__2[<spawnedEnemies>5__30];
				<enemyPrefab>5__33 = MonoSingleton<DefaultReferenceManager>.Instance.GetEnemyPrefab(<planned>5__32.type);
				if ((int)<planned>5__32.type == 40)
				{
					<enemyPrefab>5__33 = AssetsManager.funnyPowerIntroSpawn;
				}
				if ((int)<planned>5__32.type == 41)
				{
					<enemyPrefab>5__33 = AssetsManager.GetEnemiesOfType((EnemyType)41).FirstOrDefault()?.gameObject;
				}
				if (!((Object)(object)<enemyPrefab>5__33 == (Object)null))
				{
					<spawnPt>5__34 = <>4__this.spawnPoints[<>4__this.enemyRando.Next(0, <>4__this.spawnPoints.Count)];
					if ((Object)(object)<spawnPt>5__34 == (Object)null)
					{
						Debug.LogWarning((object)$"[Room] No fitting spawn point for {<planned>5__32.type} — skipping.");
					}
					else
					{
						do
						{
							<pos>5__35 = <spawnPt>5__34.position + new Vector3((float)(<>4__this.enemyRando.NextDouble() * 4.0 - 2.0), 0f, (float)(<>4__this.enemyRando.NextDouble() * 4.0 - 2.0));
						}
						while (<>4__this.IsOutOfBounds(<pos>5__35));
						if (<>4__this.isFlying(<planned>5__32.type))
						{
							<pos>5__35 += Vector3.up * 3f;
						}
						if (<planned>5__32.type == <>4__this.ReplacerType && <>4__this.allObjectActivators.Count > 0)
						{
							<objectToEnable>5__40 = <>4__this.allObjectActivators[Random.Range(0, <>4__this.allObjectActivators.Count)];
							<objectToEnable>5__40.SetActive(true);
							<>4__this.allObjectActivators.Remove(<objectToEnable>5__40);
							<>4__this._activatorsWereUsed = true;
						}
						else
						{
							<inst>5__36 = Object.Instantiate<GameObject>(<enemyPrefab>5__33, <pos>5__35, <enemyPrefab>5__33.transform.rotation);
							<inst>5__36.transform.parent = ((Component)<>4__this).transform;
							<kibr>5__37 = <inst>5__36.AddComponent<KeepInBoundsRoom>();
							<kibr>5__37.RoomInside = <>4__this;
							<eid>5__38 = <inst>5__36.GetComponent<EnemyIdentifier>() ?? <inst>5__36.GetComponentInChildren<EnemyIdentifier>();
							<kibr>5__37.eid = <eid>5__38;
							if (<maskCount>5__5 > 0 && Random.value <= 0.25f + 0.1f * (float)<maskCount>5__5)
							{
								<eid>5__38.puppet = true;
							}
							if (<planned>5__32.radianceBuffs > 0 && (Object)(object)<eid>5__38 != (Object)null)
							{
								<b>5__41 = 0;
								while (<b>5__41 < <planned>5__32.radianceBuffs)
								{
									<eid>5__38.BuffAll();
									<b>5__41++;
								}
							}
							<enemyPrefab>5__33 = null;
							<spawnPt>5__34 = null;
							<inst>5__36 = null;
							<kibr>5__37 = null;
							<eid>5__38 = null;
						}
					}
				}
				<spawnedEnemies>5__30++;
				goto IL_0b30;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SpawnPortalWhenClear>d__52 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Room <>4__this;

		private GameObject <portalPlace>5__1;

		private Vector3 <portalPos>5__2;

		private Vector3 <playerPos>5__3;

		private float <dx>5__4;

		private float <dz>5__5;

		private float <dy>5__6;

		private bool <playerIsAbovePortal>5__7;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SpawnPortalWhenClear>d__52(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<portalPlace>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0051: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<portalPlace>5__1 = GameObject.Find("PortalPlace");
				if ((Object)(object)<portalPlace>5__1 == (Object)null)
				{
					return false;
				}
				<portalPos>5__2 = <portalPlace>5__1.transform.position;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			<playerPos>5__3 = ((Component)MonoSingleton<NewMovement>.Instance).transform.position;
			<dx>5__4 = Mathf.Abs(<playerPos>5__3.x - <portalPos>5__2.x);
			<dz>5__5 = Mathf.Abs(<playerPos>5__3.z - <portalPos>5__2.z);
			<dy>5__6 = <playerPos>5__3.y - <portalPos>5__2.y;
			<playerIsAbovePortal>5__7 = <dx>5__4 <= 5f && <dz>5__5 <= 5f && <dy>5__6 >= 0f && <dy>5__6 <= 4f;
			if (!<playerIsAbovePortal>5__7)
			{
				<>4__this.CreatePortal();
				return false;
			}
			<>2__current = (object)new WaitForSeconds(0.1f);
			<>1__state = 1;
			return true;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <funnies>d__54 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Portal port;

		public GameObject eixt;

		public Room <>4__this;

		private <>c__DisplayClass54_0 <>8__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <funnies>d__54(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>8__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>8__1 = new <>c__DisplayClass54_0();
				<>8__1.eixt = eixt;
				<>8__1.port = port;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (<>8__1.port.onExitTravel == null)
				{
					<>8__1.port.onExitTravel = new UnityEventPortalTravel();
				}
				((UnityEvent<IPortalTraveller, PortalTravelDetails>)(object)<>8__1.port.onExitTravel).AddListener((UnityAction<IPortalTraveller, PortalTravelDetails>)delegate(IPortalTraveller IP, PortalTravelDetails D)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Invalid comparison between Unknown and I4
					if ((int)IP.travellerType == 1)
					{
						Object.Destroy((Object)(object)<>8__1.eixt);
						RoomGenerator.Instance.RegenerateRooms();
						Object.Destroy((Object)(object)((Component)<>8__1.port).gameObject);
					}
				});
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <spawnItem>d__51 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Transform plc;

		public Room <>4__this;

		private GameObject <ped>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <spawnItem>d__51(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<ped>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.15f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if ((Object)(object)pedestalItem == (Object)null)
				{
					pedestalItem = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Modding/RogueMode/Draghtnim/Pedestal.prefab").WaitForCompletion();
				}
				ItemPickup.CreatePickup(Plugin.GiveRandomItem(), plc);
				Object.Instantiate<GameObject>(AssetsManager.spawnEffect, plc.position, Quaternion.identity);
				if ((Object)(object)pedestalItem != (Object)null)
				{
					<ped>5__1 = Object.Instantiate<GameObject>(pedestalItem, ((Component)plc).transform.position + Vector3.up, Quaternion.identity);
					<ped>5__1.transform.parent = ((Component)<>4__this).transform;
					<ped>5__1 = null;
				}
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public Vector2Int position;

	public float spawnChance;

	public Transform exitLeft;

	public Transform exitRight;

	public Transform exitTop;

	public Transform exitBottom;

	public int SpawnCredits = 0;

	public List<Transform> spawnPoints = new List<Transform>();

	public RoomType roomType = RoomType.Normal;

	public static int roomIndex;

	private Random enemyRando;

	public BossPick bossEnemyType;

	public GameObject doorPrefab;

	public GameObject wallPrefab;

	private bool hasSpawnedEnemies = false;

	private bool rewardGiven = false;

	[Tooltip("Enemy that will activate the object instead of itself (default to wicked for nothing)")]
	public EnemyType ReplacerType = (EnemyType)10;

	[Tooltip("The objects that will be activated, will pick a random one in the list each time and will remove that one from the list once chosen. If none are left, it will just spawn the enemy like normal")]
	public List<GameObject> allObjectActivators = new List<GameObject>();

	public static bool isFighting;

	private int playerHealthAtFightStart = -1;

	private const int WaveThreshold = 28;

	private const int WaveSize = 12;

	private const int WaveResumeBelow = 8;

	private const float WavePollRate = 0.5f;

	private readonly List<GameObject> _pendingActivators = new List<GameObject>();

	private bool _activatorsWereUsed = false;

	private float _activatorSettleUntil = 0f;

	private const float ActivatorSettleTime = 6f;

	private readonly List<NavMeshObstacle> _exitObstacles = new List<NavMeshObstacle>();

	private bool tookNoDamage = true;

	public static GameObject pedestalItem;

	public bool isBossRoom => roomType == RoomType.Boss;

	private static bool HasAnyWeaponsThatCanBreakThroughGlass()
	{
		return Plugin.weapons.Any((AWeapon w) => (w.weapon == Plugin.Weapon.Revolver && (w.variant == Plugin.Variant.Blue || w.variant == Plugin.Variant.Red)) || (w.weapon == Plugin.Weapon.Shotgun && (w.variant == Plugin.Variant.Blue || w.variant == Plugin.Variant.Green)) || (w.weapon == Plugin.Weapon.Railcannon && (w.variant == Plugin.Variant.Blue || w.variant == Plugin.Variant.Red)) || w.weapon == Plugin.Weapon.RocketLauncher || (w.weapon == Plugin.Weapon.Arm && w.variant == Plugin.Variant.Red));
	}

	public void OnRoomEnter()
	{
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Invalid comparison between Unknown and I4
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Expected O, but got Unknown
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		switch (roomType)
		{
		case RoomType.Boss:
			((MonoBehaviour)this).StartCoroutine(SpawnBoss());
			break;
		case RoomType.Normal:
		{
			int itemCount = Plugin.GetItemCount("Dual Gun");
			if (itemCount > 0 && Plugin.canExecute(Plugin.LogarithmicChance(itemCount - 1, 0.15f, 0.25f, 0.9f) * 100f, ""))
			{
				MonoSingleton<CameraController>.Instance.CameraShake(0.35f);
				if ((int)MonoSingleton<PlayerTracker>.Instance.playerType == 1)
				{
					MonoSingleton<PlatformerMovement>.Instance.AddExtraHit(3);
					return;
				}
				GameObject val = new GameObject();
				val.transform.SetParent(((Component)MonoSingleton<GunControl>.Instance).transform, true);
				val.transform.localRotation = Quaternion.identity;
				DualWield[] componentsInChildren = ((Component)MonoSingleton<GunControl>.Instance).GetComponentsInChildren<DualWield>();
				if (componentsInChildren != null && componentsInChildren.Length % 2 == 0)
				{
					val.transform.localScale = new Vector3(-1f, 1f, 1f);
				}
				else
				{
					val.transform.localScale = Vector3.one;
				}
				if (componentsInChildren == null || componentsInChildren.Length == 0)
				{
					val.transform.localPosition = Vector3.zero;
				}
				else if (componentsInChildren.Length % 2 == 0)
				{
					val.transform.localPosition = new Vector3((float)(componentsInChildren.Length / 2) * -1.5f, 0f, 0f);
				}
				else
				{
					val.transform.localPosition = new Vector3((float)((componentsInChildren.Length + 1) / 2) * 1.5f, 0f, 0f);
				}
				DualWield val2 = val.AddComponent<DualWield>();
				val2.delay = 0.05f;
				val2.juiceAmount = 30f;
				if (componentsInChildren != null && componentsInChildren.Length != 0)
				{
					val2.delay += (float)componentsInChildren.Length / 20f;
				}
			}
			((MonoBehaviour)this).StartCoroutine(SpawnEnemies());
			break;
		}
		}
		if (!HasAnyWeaponsThatCanBreakThroughGlass())
		{
			Glass[] componentsInChildren2 = ((Component)this).gameObject.GetComponentsInChildren<Glass>();
			Glass[] array = componentsInChildren2;
			foreach (Glass val3 in array)
			{
				val3.Shatter();
			}
		}
	}

	[IteratorStateMachine(typeof(<SpawnEnemies>d__33))]
	private IEnumerator SpawnEnemies()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SpawnEnemies>d__33(0)
		{
			<>4__this = this
		};
	}

	private bool IsOutOfBounds(Vector3 worldPosition)
	{
		//IL_0007: 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_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = ((Component)this).transform.InverseTransformPoint(worldPosition);
		return val.x < -60f || val.x > 60f || val.z < -30f || val.z > 30f;
	}

	public static Room getObjectInsideRoom(Vector3 position)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		Vector2Int val = RoomGenerator.Instance.WorldToGrid(position);
		Room[] array = Object.FindObjectsByType<Room>((FindObjectsInactive)0, (FindObjectsSortMode)0);
		Room[] array2 = array;
		foreach (Room room in array2)
		{
			if (room.position == val)
			{
				return room;
			}
		}
		return null;
	}

	[IteratorStateMachine(typeof(<SpawnBoss>d__36))]
	private IEnumerator SpawnBoss()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SpawnBoss>d__36(0)
		{
			<>4__this = this
		};
	}

	public static Enemy FindEnemyComponent(GameObject obj)
	{
		if ((Object)(object)obj == (Object)null)
		{
			return null;
		}
		Enemy component = obj.GetComponent<Enemy>();
		if ((Object)(object)component != (Object)null)
		{
			return component;
		}
		component = obj.GetComponentInChildren<Enemy>(true);
		if ((Object)(object)component != (Object)null)
		{
			return component;
		}
		return obj.GetComponentInParent<Enemy>();
	}

	public void CreateDoor(Transform exit)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = null;
		if ((Object)(object)doorPrefab != (Object)null)
		{
			val = Object.Instantiate<GameObject>(doorPrefab, exit.position, exit.rotation * Quaternion.Euler(0f, 90f, 0f), ((Component)this).transform);
		}
		if ((Object)(object)val != (Object)null)
		{
			val.SetActive(true);
			if (roomType != 0 && roomType != RoomType.Boss && roomType != RoomType.Start && (!(Random.value <= 0.75f) || Plugin.CurrentDifficulty == 2))
			{
				((Component)val.GetComponentInChildren<Door>()).gameObject.AddComponent<Lockable>();
			}
		}
	}

	public void CreateWall(Transform exit)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)wallPrefab != (Object)null)
		{
			Object.Instantiate<GameObject>(wallPrefab, exit.position, exit.rotation, ((Component)this).transform);
		}
	}

	public void DisableExit(Transform exit)
	{
		((Component)exit).gameObject.SetActive(false);
	}

	public void CloseOffRoom()
	{
		Door[] array = Object.FindObjectsByType<Door>((FindObjectsInactive)1, (FindObjectsSortMode)0);
		foreach (Door val in array)
		{
			val.Lock();
		}
		BlockExitsWithObstacles();
	}

	private void BlockExitsWithObstacles()
	{
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		Transform[] array = (Transform[])(object)new Transform[4] { exitLeft, exitRight, exitTop, exitBottom };
		Transform[] array2 = array;
		foreach (Transform val in array2)
		{
			if (!((Object)(object)val == (Object)null))
			{
				NavMeshObstacle val2 = ((Component)val).gameObject.GetComponent<NavMeshObstacle>() ?? ((Component)val).gameObject.AddComponent<NavMeshObstacle>();
				val2.carving = true;
				val2.size = new Vector3(4f, 4f, 4f);
				((Behaviour)val2).enabled = true;
				_exitObstacles.Add(val2);
			}
		}
	}

	private void UnblockExits()
	{
		foreach (NavMeshObstacle exitObstacle in _exitObstacles)
		{
			if ((Object)(object)exitObstacle != (Object)null)
			{
				((Behaviour)exitObstacle).enabled = false;
			}
		}
		_exitObstacles.Clear();
	}

	private void Awake()
	{
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		enemyRando = new Random(Plugin.GameSeed.GetHashCode() ^ (roomIndex + 1));
		roomIndex++;
		((Component)this).gameObject.AddComponent<GoreZone>();
		bossEnemyType = RogueDifficultyManager.Instance.GetBoss();
		DeathZone[] componentsInChildren = ((Component)this).GetComponentsInChildren<DeathZone>();
		foreach (DeathZone val in componentsInChildren)
		{
			val.respawnTarget = spawnPoints[Random.Range(0, spawnPoints.Count)].position;
			val.notInstakill = true;
		}
	}

	private void Update()
	{
		//IL_004a: 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)
		DeathZone[] componentsInChildren = ((Component)this).GetComponentsInChildren<DeathZone>();
		foreach (DeathZone val in componentsInChildren)
		{
			if (val.respawnTarget.y == 0f)
			{
				val.respawnTarget = spawnPoints[Random.Range(0, spawnPoints.Count)].position;
			}
		}
		if (tookNoDamage && hasSpawnedEnemies && playerHealthAtFightStart < MonoSingleton<NewMovement>.Instance.hp)
		{
			tookNoDamage = false;
		}
		if (hasSpawnedEnemies && !rewardGiven && hasSpawnedEnemies && !rewardGiven && (!_activatorsWereUsed || !(Time.time < _activatorSettleUntil)))
		{
			EnemyIdentifier[] componentsInChildren2 = ((Component)this).GetComponentsInChildren<EnemyIdentifier>();
			EnemyIdentifier[] array = componentsInChildren2.Where((EnemyIdentifier x) => !x.dead).ToArray();
			if (array.Length == 0)
			{
				OnRoomCleared();
			}
		}
	}

	private bool isFlying(EnemyType type)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		List<EnemyType> list = new List<EnemyType>
		{
			(EnemyType)1,
			(EnemyType)5,
			(EnemyType)38
		};
		return list.Contains(type);
	}

	private void OnRoomCleared()
	{
		//IL_027b: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bb: Expected O, but got Unknown
		//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Unknown result type (might be due to invalid IL or missing references)
		//IL_0160: Expected O, but got Unknown
		//IL_0167: Unknown result type (might be due to invalid IL or missing references)
		UnblockExits();
		MonoSingleton<MusicManager>.Instance.ArenaMusicEnd();
		MonoSingleton<TimeController>.Instance.SlowDown(0.15f);
		MonoSingleton<StainVoxelManager>.Instance.ClearAll();
		GasolineProjectile[] array = Object.FindObjectsByType<GasolineProjectile>((FindObjectsInactive)1, (FindObjectsSortMode)0);
		GasolineProjectile[] array2 = array;
		foreach (GasolineProjectile val in array2)
		{
			Object.Destroy((Object)(object)((Component)val).gameObject);
		}
		rewardGiven = true;
		isFighting = false;
		if (!isBossRoom)
		{
			if (!Plugin.SelectedChar.HasPassive(Passive.HealFromBlood))
			{
				int hp = MonoSingleton<NewMovement>.Instance.hp;
				int maxHealth = Plugin.MaxHealth;
				if (hp < maxHealth)
				{
					float num = 1f - (float)hp / (float)maxHealth;
					float num2 = Mathf.Lerp(0.1f, 0.65f, num);
					if (Random.value <= num2)
					{
						int num3 = Random.Range(25, 50);
						MonoSingleton<NewMovement>.Instance.GetHealth(num3, false, false, true);
					}
				}
			}
			float num4 = (tookNoDamage ? 0.05f : 0.015f);
			if (enemyRando.NextDouble() <= (double)num4)
			{
				Vector3 val2 = spawnPoints[Random.Range(0, spawnPoints.Count)].position;
				GameObject val3 = new GameObject("ItemDropAnchor");
				val3.transform.position = val2;
				((MonoBehaviour)this).StartCoroutine(spawnItem(val3.transform));
			}
			else
			{
				float num5 = (float)enemyRando.NextDouble() + (tookNoDamage ? 0.2f : 0f);
				if (!(num5 <= 0.22f))
				{
					if (num5 <= 0.44f)
					{
						RogueDifficultyManager.Instance.Keys++;
						if (tookNoDamage)
						{
							Debug.Log((object)"[Room] Flawless clear! Awarded a key.");
						}
					}
					else
					{
						int num6 = enemyRando.Next(1, tookNoDamage ? 4 : 3);
						for (int j = 0; j < num6; j++)
						{
							RogueDifficultyManager.Instance.Gold++;
						}
						if (tookNoDamage)
						{
							Debug.Log((object)$"[Room] Flawless clear! Awarded {num6} gold.");
						}
					}
				}
			}
		}
		else
		{
			Vector3 val4 = ((Component)this).transform.position + new Vector3(Random.Range(-2f, 2f), 1f, Random.Range(-2f, 2f));
			GameObject val5 = new GameObject("aaaaaaaaaaaa");
			val5.transform.position = val4;
			val5.transform.parent = ((Component)this).transform;
			((MonoBehaviour)this).StartCoroutine(spawnItem(val5.transform));
			MonoSingleton<NewMovement>.Instance.FullHeal(false);
			((MonoBehaviour)this).StartCoroutine(SpawnPortalWhenClear());
		}
		Door[] array3 = Object.FindObjectsByType<Door>((FindObjectsInactive)1, (FindObjectsSortMode)0);
		Lockable lockable = default(Lockable);
		foreach (Door val6 in array3)
		{
			if (!((Component)val6).TryGetComponent<Lockable>(ref lockable) || !lockable.locked)
			{
				val6.Unlock();
			}
		}
	}

	[IteratorStateMachine(typeof(<spawnItem>d__51))]
	private IEnumerator spawnItem(Transform plc)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <spawnItem>d__51(0)
		{
			<>4__this = this,
			plc = plc
		};
	}

	[IteratorStateMachine(typeof(<SpawnPortalWhenClear>d__52))]
	private IEnumerator SpawnPortalWhenClear()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SpawnPortalWhenClear>d__52(0)
		{
			<>4__this = this
		};
	}

	public void CreatePortal()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Expected O, but got Unknown
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: 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_0189: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("PortalEntry");
		val.transform.position = GameObject.Find("PortalPlace").transform.position;
		val.transform.Rotate(90f, 0f, 0f);
		GameObject val2 = new GameObject("PortalExit");
		val2.transform.position = GameObject.Find("PortalPos").transform.position;
		val2.transform.Rotate(-90f, 0f, 0f);
		Portal val3 = val.AddComponent<Portal>();
		val3.shape = (IPortalShape)(object)new PlaneShape
		{
			width = 10f,
			height = 10f
		};
		val3.entry = val2.transform;
		val3.exit = val.transform;
		val3.supportInfiniteRecursion = true;
		val3.appearsInRecursions = true;
		val3.canSeeItself = true;
		val3.clippingMethod = (PortalClippingMethod)0;
		val3.maxRecursions = 3;
		val3.renderSettings = (PortalSideFlags)6;
		val3.useFogEnter = true;
		val3.useFogExit = true;
		val3.canSeePortalLayer = true;
		Portal val4 = val2.AddComponent<Portal>();
		val4.shape = (IPortalShape)(object)new PlaneShape
		{
			width = 10f,
			height = 10f
		};
		val4.entry = val.transform;
		val4.exit = val2.transform;
		val4.supportInfiniteRecursion = true;
		val4.appearsInRecursions = true;
		val4.canSeeItself = true;
		val4.clippingMethod = (PortalClippingMethod)0;
		val4.maxRecursions = 3;
		val4.renderSettings = (PortalSideFlags)6;
		val4.useFogEnter = true;
		val4.useFogExit = true;
		val4.canSeePortalLayer = true;
		PortalIdentifier val5 = val2.AddComponent<PortalIdentifier>();
		val5.isTraversable = true;
		GameObject.Find("PortalPlace").SetActive(false);
		((MonoBehaviour)this).StartCoroutine(funnies(val3, val2));
	}

	[IteratorStateMachine(typeof(<funnies>d__54))]
	private IEnumerator funnies(Portal port, GameObject eixt)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <funnies>d__54(0)
		{
			<>4__this = this,
			port = port,
			eixt = eixt
		};
	}

	public Vector3 GetOffset(Transform exit)
	{
		//IL_0002: 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_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: 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)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		float num = Vector3.Distance(exit.position, ((Component)this).transform.position);
		Vector3 val = exit.position - ((Component)this).transform.position;
		Vector3 normalized = ((Vector3)(ref val)).normalized;
		return normalized * num;
	}
}
public class KeepInBoundsRoom : MonoBehaviour
{
	public Room RoomInside;

	public EnemyIdentifier eid;

	private NavMeshAgent _agent;

	private Rigidbody _rb;

	private const float XLimit = 55f;

	private const float ZLimit = 25f;

	private int _consecutiveFramesOut;

	private const int MaxFramesOut = 30;

	public bool ResetVelocity = true;

	private void Start()
	{
		_agent = ((Component)this).GetComponent<NavMeshAgent>() ?? ((Component)this).GetComponentInChildren<NavMeshAgent>();
		_rb = ((Component)this).GetComponent<Rigidbody>() ?? ((Component)this).GetComponentInChildren<Rigidbody>();
	}

	private void LateUpdate()
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//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_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: 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)
		if ((Object)(object)RoomInside == (Object)null)
		{
			return;
		}
		Vector3 val = ((Component)RoomInside).transform.InverseTransformPoint(((Component)this).transform.position);
		if (!(val.x < -55f) && !(val.x > 55f) && !(val.z < -25f) && !(val.z > 25f))
		{
			return;
		}
		_consecutiveFramesOut++;
		if (_consecutiveFramesOut >= 30)
		{
			if ((Object)(object)eid != (Object)null)
			{
				eid.InstaKill();
			}
			Object.Destroy((Object)(object)this);
			return;
		}
		val.x = Mathf.Clamp(val.x, -55f, 55f);
		val.z = Mathf.Clamp(val.z, -25f, 25f);
		Vector3 position = ((Component)RoomInside).transform.position;
		if ((Object)(object)_rb != (Object)null && ResetVelocity)
		{
			_rb.velocity = Vector3.zero;
			_rb.angularVelocity = Vector3.zero;
		}
		if ((Object)(object)_agent != (Object)null && ((Behaviour)_agent).isActiveAndEnabled)
		{
			_agent.ResetPath();
			_agent.Warp(position);
		}
		else
		{
			((Component)this).transform.position = position;
		}
	}
}
public class RoomGenerator : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <>c__DisplayClass30_0
	{
		public GameObject quad1;

		public GameObject quad2;

		public RoomGenerator <>4__this;

		internal void <GenerateRooms>b__1(IPortalTraveller IP, PortalTravelDetails D)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)IP.travellerType == 1)
			{
				((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.StartThingggg(quad1, quad2));
			}
		}
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass46_0
	{
		public NavMeshSurface surface;

		internal bool <buildDaMesh>b__0()
		{
			return (Object)(object)surface.navMeshData != (Object)null;
		}
	}

	[CompilerGenerated]
	private sealed class <GenerateRooms>d__30 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public bool firstTime;

		public RoomGenerator <>4__this;

		private float <floor>5__1;

		private int <count>5__2;

		private Vector2Int <current>5__3;

		private int <placed>5__4;

		private int <safetyBreak>5__5;

		private int <special>5__6;

		private Vector2Int <dir>5__7;

		private int <steps>5__8;

		private int <back>5__9;

		private int <i>5__10;

		private Vector2Int <next>5__11;

		private List<Room> <compatible>5__12;

		private <>c__DisplayClass30_0 <>8__13;

		private Portal <portal1>5__14;

		private PortalIdentifier <portalIdent>5__15;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <GenerateRooms>d__30(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<compatible>5__12 = null;
			<>8__13 = null;
			<portal1>5__14 = null;
			<portalIdent>5__15 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Expected O, but got Unknown
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Expected O, but got Unknown
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_061e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0628: Expected O, but got Unknown
			//IL_063e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0648: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Expected O, but got Unknown
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: 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_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.canDoTheErrorRoom = false;
				<>4__this.guaranteedCombatRoomsWithCredits = 0;
				<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)MonoSingleton<DefaultReferenceManager>.Instance != (Object)null));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (!firstTime)
				{
					<>2__current = (object)new WaitForSeconds(6f);
					<>1__state = 2;
					return true;
				}
				goto IL_00bf;
			case 2:
				<>1__state = -1;
				goto IL_00bf;
			case 3:
				<>1__state = -1;
				<>8__13.quad1 = new GameObject("PortalEntry");
				<>8__13.quad1.transform.position = new Vector3(0f, 65f, 0f);
				<>8__13.quad1.transform.Rotate(-90f, 0f, 0f);
				<>8__13.quad2 = new GameObject("PortalExit");
				<>8__13.quad2.transform.position = GameObject.Find("Pit").transform.Find("Cube (2)").position + Vector3.up * 4f;
				<>8__13.quad2.transform.Rotate(90f, 0f, 0f);
				<portal1>5__14 = <>8__13.quad1.AddComponent<Portal>();
				<portal1>5__14.shape = (IPortalShape)(object)new PlaneShape
				{
					width = 10f,
					height = 10f
				};
				<portal1>5__14.entry = <>8__13.quad2.transform;
				<portal1>5__14.exit = <>8__13.quad1.transform;
				<portal1>5__14.supportInfiniteRecursion = true;
				<portal1>5__14.appearsInRecursions = true;
				<portal1>5__14.canSeeItself = true;
				<portal1>5__14.clippingMethod = (PortalClippingMethod)0;
				<portal1>5__14.maxRecursions = 3;
				<portal1>5__14.renderSettings = (PortalSideFlags)6;
				<portal1>5__14.useFogEnter = true;
				<portal1>5__14.useFogExit = true;
				<portal1>5__14.canSeePortalLayer = true;
				<portalIdent>5__15 = <>8__13.quad2.AddComponent<PortalIdentifier>();
				<portalIdent>5__15.isTraversable = true;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 4;
				return true;
			case 4:
				{
					<>1__state = -1;
					<portal1>5__14.onEntryTravel = new UnityEventPortalTravel();
					((UnityEvent<IPortalTraveller, PortalTravelDetails>)(object)<portal1>5__14.onEntryTravel).AddListener((UnityAction<IPortalTraveller, PortalTravelDetails>)delegate(IPortalTraveller IP, PortalTravelDetails D)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						//IL_0008: Invalid comparison between Unknown and I4
						if ((int)IP.travellerType == 1)
						{
							((MonoBehaviour)<>8__13.<>4__this).StartCoroutine(<>8__13.<>4__this.StartThingggg(<>8__13.quad1, <>8__13.quad2));
						}
					});
					<>8__13 = null;
					<portal1>5__14 = null;
					<portalIdent>5__15 = null;
					break;
				}
				IL_00bf:
				if (<>4__this.roomPrefabs == null || <>4__this.roomPrefabs.Count == 0)
				{
					Debug.LogWarning((object)"[RoomGenerator] No room prefabs assigned — skipping generation.");
					return false;
				}
				<floor>5__1 = RogueDifficultyManager.Instance.floor;
				<count>5__2 = Mathf.RoundToInt(9f + Mathf.Log(<floor>5__1 + 1f, 2f) * 4f + (float)RogueDifficultyManager.RoomRNG.Next(-1, 2));
				<current>5__3 = Vector2Int.zero;
				<>4__this.PlaceRoom(<current>5__3, isStart: true);
				<placed>5__4 = 1;
				<safetyBreak>5__5 = 0;
				while (<placed>5__4 < <count>5__2 && <safetyBreak>5__5++ < 1000)
				{
					<dir>5__7 = <>4__this.directions[RogueDifficultyManager.RoomRNG.Next(0, <>4__this.directions.Length)];
					<steps>5__8 = RogueDifficultyManager.RoomRNG.Next(1, 2);
					<i>5__10 = 0;
					while (<i>5__10 < <steps>5__8 && <placed>5__4 < <count>5__2)
					{
						<next>5__11 = <current>5__3 + <dir>5__7;
						if (<>4__this.placedRooms.ContainsKey(<next>5__11) || !<>4__this.RoomHasExit(<>4__this.placedRooms[<current>5__3], <dir>5__7))
						{
							break;
						}
						<compatible>5__12 = <>4__this.CompatiblePrefabs(-<dir>5__7);
						if (<compatible>5__12.Count == 0)
						{
							break;
						}
						<>4__this.PlaceRoom(<next>5__11, isStart: false, <compatible>5__12);
						<current>5__3 = <next>5__11;
						<placed>5__4++;
						<compatible>5__12 = null;
						<i>5__10++;
					}
					<back>5__9 = RogueDifficultyManager.RoomRNG.Next(1, <>4__this.path.Count);
					<current>5__3 = <>4__this.path[<>4__this.path.Count - 1 - Mathf.Min(<back>5__9, <>4__this.path.Count - 1)];
				}
				<>4__this.DesignateBossRoom();
				<>4__this.PlaceSpecialRooms();
				<>4__this.EnforceEmptyRoomConnectivity();
				<>4__this.FinalizeConnections();
				<>4__this.BuildNavMesh();
				<special>5__6 = 3;
				Debug.Log((object)$"[RoomGenerator] Spawned {<placed>5__4} combat rooms + {<special>5__6} special rooms + 1 boss room.");
				if (!firstTime)
				{
					<>8__13 = new <>c__DisplayClass30_0();
					<>8__13.<>4__this = <>4__this;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 3;
					return true;
				}
				<>4__this.canDoTheErrorRoom = true;
				break;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <StartThingggg>d__31 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject quad1;

		public GameObject quad2;

		public RoomGenerator <>4__this;

		private NewMovement <nm>5__1;

		private GunControl <gc>5__2;

		private int <index>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <StartThingggg>d__31(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<nm>5__1 = null;
			<gc>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<nm>5__1 = MonoSingleton<NewMovement>.Instance;
				<gc>5__2 = MonoSingleton<GunControl>.Instance;
				GameStateManager.Instance.PopState("pit-falling");
				if (!<nm>5__1.activated)
				{
					<nm>5__1.activated = true;
					<nm>5__1.cc.activated = true;
					<nm>5__1.cc.CameraShake(1f);
					((Behaviour)<nm>5__1.cc).enabled = true;
				}
				<gc>5__2.YesWeapon();
				MonoSingleton<PlayerActivatorRelay>.Instance.ResetIndex();
				MonoSingleton<PlayerActivatorRelay>.Instance.Activate();
				if (<nm>5__1.levelOver)
				{
					<nm>5__1.levelOver = false;
					MonoSingleton<StatsManager>.Instance.UnhideShit();
				}
				PlayerActivator.lastActivatedPosition = ((Component)MonoSingleton<NewMovement>.Instance).transform.position;
				MonoSingleton<FistControl>.Instance.YesFist();
				quad1.transform.position = Vector3.one * 9999f;
				quad2.transform.position = Vector3.one * 9999f;
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				Object.Destroy((Object)(object)quad2);
				Object.Destroy((Object)(object)quad1);
				MonoSingleton<StatsManager>.Instance.StartTimer();
				<index>5__3 = Random.Range(0, <>4__this.CalmMusic.Count);
				MonoSingleton<MusicManager>.Instance.cleanTheme.clip = <>4__this.CalmMusic[<index>5__3];
				MonoSingleton<MusicManager>.Instance.bossTheme.clip = <>4__this.UnCalmMusic[<index>5__3];
				MonoSingleton<MusicManager>.Instance.battleTheme.clip = <>4__this.UnCalmMusic[<index>5__3];
				MonoSingleton<MusicManager>.Instance.StartMusic();
				<>4__this.canDoTheErrorRoom = true;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <buildDaMesh>d__46 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public RoomGenerator <>4__this;

		private <>c__DisplayClass46_0 <>8__1;

		private SandboxNavmesh <instance>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <buildDaMesh>d__46(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>8__1 = null;
			<instance>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>8__1 = new <>c__DisplayClass46_0();
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if ((Object)(object)MonoSingleton<SandboxNavmesh>.Instance != (Object)null)
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				<>8__1.surface = Object.FindObjectOfType<NavMeshSurface>();
				if ((Object)(object)<>8__1.surface == (Object)null)
				{
					<>8__1.surface = ((Component)<>4__this).gameObject.AddComponent<NavMeshSurface>();
				}
				<>8__1.surface.navMeshData = null;
				<>8__1.surface.BuildNavMesh();
				<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)<>8__1.surface.navMeshData != (Object)null));
				<>1__state = 3;
				return true;
			case 2:
				<>1__state = -1;
				<instance>5__2 = MonoSingleton<SandboxNavmesh>.Instance;
				<instance>5__2.navmeshBuilt = (UnityAction)Delegate.Combine((Delegate?)(object)<instance>5__2.navmeshBuilt, (Delegate?)new UnityAction(<>4__this.NavmeshBuilt));
				MonoSingleton<SandboxNavmesh>.Instance.Rebake();
				return false;
			case 3:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this._generationComplete = true;
				<>4__this.UpdateRoomActivation();
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[Header("Generation Settings")]
	private int minRooms = 5;

	private int maxRooms = 13;

	[Header("Room Prefabs")]
	[Tooltip("Normal combat room prefabs — one is chosen at random per room.")]
	public List<Room> roomPrefabs = new List<Room>();

	[Tooltip("Optional dedicated prefab for each special room type.\nFalls back to a random roomPrefab when left empty.")]
	public Room treasureRoomPrefab;

	public Room shopRoomPrefab;

	public Room gamblingRoomPrefab;

	public Room bossRoomPrefab;

	public Room startRoomPrefab;

	[Tooltip("SECRET ROOOMMMS")]
	public List<Room> SecretRoomPrefabs = new List<Room>();

	[Header("Boss Room Settings")]
	[Tooltip("EnemyType spawned in the boss room.")]
	public EnemyType bossEnemyType = (EnemyType)18;

	public Dictionary<Vector2Int, Room> placedRooms = new Dictionary<Vector2Int, Room>();

	private List<Vector2Int> path = new List<Vector2Int>();

	private readonly Vector2Int[] directions = (Vector2Int[])(object)new Vector2Int[4]
	{
		Vector2Int.up,
		Vector2Int.down,
		Vector2Int.left,
		Vector2Int.right
	};

	public List<AudioClip> CalmMusic = new List<AudioClip>();

	public List<AudioClip> UnCalmMusic = new List<AudioClip>();

	[Header("Room Size")]
	private float roomWidth = 60f;

	private float roomHeight = 30f;

	[Header("Performance")]
	[Tooltip("How many grid cells away from the player rooms stay active (1 = current + immediate neighbors).")]
	private int activationRadius = 2;

	private bool _generationComplete = false;

	private float _nextActivationCheck = 0f;

	private const float ActivationCheckInterval = 0.3f;

	private int guaranteedCombatRoomsWithCredits;

	private const int MinCombatRoomsWithCredits = 4;

	private bool canDoTheErrorRoom = false;

	private const float ErrorRoomRadius = 100f;

	private bool _isTeleportingToErrorRoom = false;

	public static RoomGenerator Instance { get; private set; }

	private void Awake()
	{
		Room.roomIndex = 0;
		Instance = this;
		((MonoBehaviour)this).StartCoroutine(GenerateRooms());
	}

	public void RegenerateRooms()
	{
		((MonoBehaviour)this).StopAllCoroutines();
		MonoSingleton<StatsManager>.Instance.StopTimer();
		MonoSingleton<MusicManager>.Instance.StopMusic();
		foreach (Room value in placedRooms.Values)
		{
			if ((Object)(object)value != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)value).gameObject);
			}
		}
		placedRooms.Clear();
		path.Clear();
		_generationComplete = false;
		if ((Object)(object)MinimapUI.Instance != (Object)null)
		{
			MinimapUI.Instance.ClearAndReset();
		}
		RogueDifficultyManager.Instance.MoveStage();
		((MonoBehaviour)this).StartCoroutine(GenerateRooms(firstTime: false));
	}

	[IteratorStateMachine(typeof(<GenerateRooms>d__30))]
	private IEnumerator GenerateRooms(bool firstTime = true)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <GenerateRooms>d__30(0)
		{
			<>4__this = this,
			firstTime = firstTime
		};
	}

	[IteratorStateMachine(typeof(<StartThingggg>d__31))]
	private IEnumerator StartThingggg(GameObject quad1, GameObject quad2)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <StartThingggg>d__31(0)
		{
			<>4__this = this,
			quad1 = quad1,
			quad2 = quad2
		};
	}

	private Transform GetExitFacing(Room room, Vector2Int dir)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		if (dir == Vector2Int.up)
		{
			return room.exitTop;
		}
		if (dir == Vector2Int.down)
		{
			return room.exitBottom;
		}
		if (dir == Vector2Int.left)
		{
			return room.exitLeft;
		}
		if (dir == Vector2Int.right)
		{
			return room.exitRight;
		}
		return null;
	}

	private bool RoomHasExit(Room room, Vector2Int dir)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		return (Object)(object)GetExitFacing(room, dir) != (Object)null;
	}

	private List<Room> CompatiblePrefabs(Vector2Int dir)
	{
		//IL_000e: 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)
		return roomPrefabs.FindAll((Room p) => RoomHasExit(p, dir));
	}

	private bool PrefabFitsNeighbours(Room prefab, Vector2Int gridPos)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: 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_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		Vector2Int[] array = directions;
		foreach (Vector2Int val in array)
		{
			if (placedRooms.ContainsKey(gridPos + val))
			{
				Room room = placedRooms[gridPos + val];
				bool flag = RoomHasExit(room, -val);
				bool flag2 = RoomHasExit(prefab, val);
				if (flag && !flag2)
				{
					return false;
				}
			}
		}
		return true;
	}

	private void AlignRoomToNeighborExit(Room room, Vector2Int gridPos)
	{
		//IL_0012: 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_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: 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_0076: 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_0095: 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_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		Vector2Int[] array = directions;
		foreach (Vector2Int val in array)
		{
			Vector2Int key = gridPos + val;
			if (placedRooms.TryGetValue(key, out Room value))
			{
				Transform exitFacing = GetExitFacing(value, -val);
				Transform exitFacing2 = GetExitFacing(room, val);
				if (!((Object)(object)exitFacing == (Object)null) && !((Object)(object)exitFacing2 == (Object)null))
				{
					float num = exitFacing2.position.y - ((Component)room).transform.position.y;
					float num2 = exitFacing.position.y - num;
					Vector3 position = ((Component)room).transform.position;
					((Component)room).transform.position = new Vector3(position.x, num2, position.z);
					break;
				}
			}
		}
	}

	private void PlaceRoom(Vector2Int gridPos, bool isStart = false, List<Room> prefabPool = null)
	{
		//IL_000e: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		Room room;
		if (isStart)
		{
			room = startRoomPrefab;
		}
		else
		{
			List<Room> list = prefabPool ?? roomPrefabs;
			List<Room> list2 = list.FindAll((Room p) => PrefabFitsNeighbours(p, gridPos));
			if (list2.Count > 0)
			{
				room = list2[RogueDifficultyManager.RoomRNG.Next(0, list2.Count)];
			}
			else
			{
				Debug.LogWarning((object)($"[RoomGenerator] No fully-compatible prefab found at {gridPos}; " + "falling back to partially-compatible pool."));
				room = list[RogueDifficultyManager.RoomRNG.Next(0, list.Count)];
			}
		}
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor((float)((Vector2Int)(ref gridPos)).x * roomWidth, 0f, (float)((Vector2Int)(ref gridPos)).y * roomHeight);
		Room room2 = Object.Instantiate<Room>(room, val, Quaternion.identity);
		room2.position = gridPos;
		room2.roomType = RoomType.Normal;
		if (isStart)
		{
			room2.SpawnCredits = 0;
		}
		else
		{
			room2.SpawnCredits = 3;
		}
		if (!isStart)
		{
			AlignRoomToNeighborExit(room2, gridPos);
		}
		placedRooms[gridPos] = room2;
		path.Add(gridPos);
	}

	private void PlaceSpecialRooms()
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: 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)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		List<Vector2Int> candidates = FindDeadEndCandidates();
		for (int num = candidates.Count - 1; num > 0; num--)
		{
			int num2 = RogueDifficultyManager.RoomRNG.Next(0, num + 1);
			List<Vector2Int> list = candidates;
			int index = num;
			List<Vector2Int> list2 = candidates;
			int index2 = num2;
			Vector2Int value = candidates[num2];
			Vector2Int value2 = candidates[num];
			list[index] = value;
			list2[index2] = value2;
		}
		TryPlaceSpecialRoom(ref candidates, RoomType.Treasure);
		TryPlaceSpecialRoom(ref candidates, RoomType.Shop);
		TryPlaceSpecialRoom(ref candidates, RoomType.Gambling);
	}

	private List<Vector2Int> FindDeadEndCandidates()
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		List<Vector2Int> list = new List<Vector2Int>();
		foreach (Vector2Int key in placedRooms.Keys)
		{
			Vector2Int[] array = directions;
			foreach (Vector2Int val in array)
			{
				Vector2Int val2 = key + val;
				if (placedRooms.ContainsKey(val2))
				{
					continue;
				}
				int num = 0;
				Vector2Int[] array2 = directions;
				foreach (Vector2Int val3 in array2)
				{
					if (placedRooms.ContainsKey(val2 + val3))
					{
						num++;
					}
				}
				if (num == 1 && !list.Contains(val2))
				{
					list.Add(val2);
				}
			}
		}
		if (list.Count < 3)
		{
			Debug.LogWarning((object)("[RoomGenerator] Fewer than 3 dead-end slots found for special rooms " + $"({list.Count} available). Some special rooms may be skipped."));
		}
		return list;
	}

	private void TryPlaceSpecialRoom(ref List<Vector2Int> candidates, RoomType roomType)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0324: Unknown result type (might be due to invalid IL or missing references)
		//IL_034a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0370: Unknown result type (might be due to invalid IL or missing references)
		//IL_0388: Unknown result type (might be due to invalid IL or missing references)
		//IL_0404: Unknown result type (might be due to invalid IL or missing references)
		//IL_0405: Unknown result type (might be due to invalid IL or missing references)
		//IL_0414: Unknown result type (might be due to invalid IL or missing references)
		//IL_0419: Unknown result type (might be due to invalid IL or missing references)
		//IL_0432: Unknown result type (might be due to invalid IL or missing references)
		//IL_0444: Unknown result type (might be due to invalid IL or missing references)
		//IL_045d: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: 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)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: 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)
		//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_0211: Unknown result type (might be due to invalid IL or missing references)
		//IL_0225: Unknown result type (might be due to invalid IL or missing references)
		//IL_0249: Unknown result type (might be due to invalid IL or missing references)
		//IL_0271: Unknown result type (might be due to invalid IL or missing references)
		//IL_0285: Unknown result type (might be due to invalid IL or missing references)
		Vector2Int pos = Vector2Int.zero;
		bool flag = false;
		Room room;
		while (candidates.Count > 0)
		{
			pos = candidates[0];
			candidates.RemoveAt(0);
			candidates.RemoveAll(delegate(Vector2Int c)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				Vector2Int[] array3 = directions;
				foreach (Vector2Int val4 in array3)
				{
					if (c == pos + val4)
					{
						return true;
					}
				}
				return false;
			});
			bool flag2 = false;
			Vector2Int[] array = directions;
			foreach (Vector2Int val in array)
			{
				if (placedRooms.TryGetValue(pos + val, out Room value) && value.roomType != 0)
				{
					flag2 = true;
					break;
				}
			}
			if (flag2)
			{
				Debug.Log((object)$"[RoomGenerator] Skipping {roomType} candidate {pos} — adjacent to a special room.");
				continue;
			}
			if (1 == 0)
			{
			}
			room = roomType switch
			{
				RoomType.Treasure => treasureRoomPrefab, 
				RoomType.Shop => shopRoomPrefab, 
				RoomType.Gambling => gamblingRoomPrefab, 
				_ => null, 
			};
			if (1 == 0)
			{
			}
			Room room2 = room;
			bool flag3 = true;
			Vector2Int[] array2 = directions;
			foreach (Vector2Int val2 in array2)
			{
				if (placedRooms.TryGetValue(pos + val2, out Room value2))
				{
					if (!RoomHasExit(value2, -val2))
					{
						flag3 = false;
						Debug.Log((object)($"[RoomGenerator] Skipping {roomType} candidate {pos} — " + $"neighbour at {pos + val2} has no exit toward it."));
						break;
					}
					if ((Object)(object)room2 != (Object)null && !RoomHasExit(room2, val2))
					{
						flag3 = false;
						Debug.Log((object)($"[RoomGenerator] Skipping {roomType} candidate {pos} — " + $"dedicated prefab has no exit in direction {val2}."));
						break;
					}
					if ((Object)(object)room2 == (Object)null && CompatiblePrefabs(val2).Count == 0)
					{
						flag3 = false;
						Debug.Log((object)($"[RoomGenerator] Skipping {roomType} candidate {pos} — " + $"no normal prefab has exit in direction {val2}."));
						break;
					}
				}
			}
			if (!flag3)
			{
				continue;
			}
			flag = true;
			break;
		}
		if (!flag)
		{
			Debug.LogWarning((object)$"[RoomGenerator] No valid candidate for {roomType} room — skipping.");
			return;
		}
		if (1 == 0)
		{
		}
		room = roomType switch
		{
			RoomType.Treasure => ((Object)(object)treasureRoomPrefab != (Object)null) ? treasureRoomPrefab : PickCompatibleNormalPrefab(pos), 
			RoomType.Shop => ((Object)(object)shopRoomPrefab != (Object)null) ? shopRoomPrefab : PickCompatibleNormalPrefab(pos), 
			RoomType.Gambling => ((Object)(object)gamblingRoomPrefab != (Object)null) ? gamblingRoomPrefab : PickCompatibleNormalPrefab(pos), 
			_ => PickCompatibleNormalPrefab(pos), 
		};
		if (1 == 0)
		{
		}
		Room room3 = room;
		if ((Object)(object)room3 == (Object)null)
		{
			Debug.LogWarning((object)$"[RoomGenerator] Could not resolve a prefab for {roomType} at {pos} — skipping.");
			return;
		}
		Vector3 val3 = default(Vector3);
		((Vector3)(ref val3))..ctor((float)((Vector2Int)(ref pos)).x * roomWidth, 0f, (float)((Vector2Int)(ref pos)).y * roomHeight);
		Room room4 = Object.Instantiate<Room>(room3, val3, Quaternion.identity);
		room4.position = pos;
		room4.roomType = roomType;
		room4.SpawnCredits = 0;
		AlignRoomToNeighborExit(room4, pos);
		placedRooms[pos] = room4;
		Debug.Log((object)$"[RoomGenerator] {roomType} room placed at grid {pos}.");
	}

	private Room PickCompatibleNormalPrefab(Vector2Int gridPos)
	{
		//IL_000e: 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_005a: Unknown result type (might be due to invalid IL or missing references)
		List<Room> list = roomPrefabs.FindAll((Room p) => PrefabFitsNeighbours(p, gridPos));
		if (list.Count > 0)
		{
			return list[RogueDifficultyManager.RoomRNG.Next(0, list.Count)];
		}
		Debug.LogWarning((object)$"[RoomGenerator] No fully-compatible normal prefab for {gridPos}; using any.");
		return (roomPrefabs.Count > 0) ? roomPrefabs[RogueDifficultyManager.RoomRNG.Next(0, roomPrefabs.Count)] : null;
	}

	private void DesignateBossRoom()
	{
		//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_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0303: Unknown result type (might be due to invalid IL or missing references)
		//IL_0310: Unknown result type (might be due to invalid IL or missing references)
		//IL_0315: Unknown result type (might be due to invalid IL or missing references)
		//IL_0328: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_033e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0350: Unknown result type (might be due to invalid IL or missing references)
		//IL_035b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0361: Unknown result type (might be due to invalid IL or missing references)
		//IL_0366: Unknown result type (might be due to invalid IL or missing references)
		//IL_0374: Unknown result type (might be due to invalid IL or missing references)
		//IL_0375: Unknown result type (might be due to invalid IL or missing references)
		//IL_0385: Unknown result type (might be due to invalid IL or missing references)
		//IL_0392: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0224: Unknown result type (might be due to invalid IL or missing references)
		//IL_0229: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_0266: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0280: Unknown result type (might be due to invalid IL or missing references)
		//IL_0285: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_029a: Unknown result type (might be due to invalid IL or missing references)
		//IL_018b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0190: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: 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_02bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
		Vector2Int val = Vector2Int.zero;
		int num = -1;
		Vector2Int key;
		foreach (KeyValuePair<Vector2Int, Room> placedRoom in placedRooms)
		{
			if (placedRoom.Key == Vector2Int.zero || placedRoom.Value.roomType != 0)
			{
				continue;
			}
			int num2 = 0;
			Vector2Int[] array = directions;
			foreach (Vector2Int val2 in array)
			{
				if (placedRooms.ContainsKey(placedRoom.Key + val2))
				{
					num2++;
				}
			}
			if (num2 != 1)
			{
				continue;
			}
			bool flag = false;
			Vector2Int[] array2 = directions;
			foreach (Vector2Int val3 in array2)
			{
				if (placedRooms.TryGetValue(placedRoom.Key + val3, out Room value) && value.roomType != 0 && value.roomType != RoomType.Boss)
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				continue;
			}
			if ((Object)(object)bossRoomPrefab != (Object)null && !BossPrefabFitsPosition(placedRoom.Key))
			{
				Debug.Log((object)($"[RoomGenerator] Skipping boss candidate {placedRoom.Key} — " + "boss prefab lacks a required exit toward its neighbour."));
				continue;
			}
			key = placedRoom.Key;
			int num3 = Mathf.Abs(((Vector2Int)(ref key)).x);
			key = placedRoom.Key;
			int num4 = num3 + Mathf.Abs(((Vector2Int)(ref key)).y);
			if (num4 > num)
			{
				num = num4;
				val = placedRoom.Key;
			}
		}
		if (num < 0)
		{
			Debug.LogWarning((object)"[RoomGenerator] No dead-end normal room found for boss — falling back to farthest normal room.");
			foreach (KeyValuePair<Vector2Int, Room> placedRoom2 in placedRooms)
			{
				if (!(placedRoom2.Key == Vector2Int.zero) && placedRoom2.Value.roomType == RoomType.Normal && (!((Object)(object)bossRoomPrefab != (Object)null) || BossPrefabFitsPosition(placedRoom2.Key)))
				{
					key = placedRoom2.Key;
					int num5 = Mathf.Abs(((Vector2Int)(ref key)).x);
					key = placedRoom2.Key;
					int num6 = num5 + Mathf.Abs(((Vector2Int)(ref key)).y);
					if (num6 > num)
					{
						num = num6;
						val = placedRoom2.Key;
					}
				}
			}
		}
		if (num < 0)
		{
			Debug.LogWarning((object)"[RoomGenerator] Could not find a valid boss room candidate.");
			return;
		}
		Room room = placedRooms[val];
		Vector3 position = ((Component)room).transform.position;
		Object.Destroy((Object)(object)((Component)room).gameObject);
		placedRooms.Remove(val);
		Room room2 = (((Object)(object)bossRoomPrefab != (Object)null) ? bossRoomPrefab : PickCompatibleNormalPrefab(val));
		Room room3 = Object.Instantiate<Room>(room2, new Vector3(position.x, 0f, position.z), Quaternion.identity);
		room3.position = val;
		room3.roomType = RoomType.Boss;
		AlignRoomToNeighborExit(room3, val);
		placedRooms[val] = room3;
		Debug.Log((object)$"[RoomGenerator] Boss room at grid {val} (Manhattan {num}).");
	}

	private bool BossPrefabFitsPosition(Vector2Int gridPos)
	{
		//IL_0023: 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_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_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)bossRoomPrefab == (Object)null)
		{
			return true;
		}
		Vector2Int[] array = directions;
		foreach (Vector2Int val in array)
		{
			if (placedRooms.TryGetValue(gridPos + val, out Room value) && RoomHasExit(value, -val) && !RoomHasExit(bossRoomPrefab, val))
			{
				return false;
			}
		}
		return true;
	}

	private void BuildNavMesh()
	{
		((MonoBehaviour)this).StartCoroutine(buildDaMesh());
	}

	private void NavmeshBuilt()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Expected O, but got Unknown
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Expected O, but got Unknown
		SandboxNavmesh instance = MonoSingleton<SandboxNavmesh>.Instance;
		instance.navmeshBuilt = (UnityAction)Delegate.Remove((Delegate?)(object)instance.navmeshBuilt, (Delegate?)new UnityAction(NavmeshBuilt));
		_generationComplete = true;
		UpdateRoomActivation();
	}

	[IteratorStateMachine(typeof(<buildDaMesh>d__46))]
	private IEnumerator buildDaMesh()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <buildDaMesh>d__46(0)
		{
			<>4__this = this
		};
	}

	private void FinalizeConnections()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: 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_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: 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)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: 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_0190: Unknown result type (might be due to invalid IL or missing references)
		//IL_0192: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		HashSet<(Vector2Int, Vector2Int)> hashSet = new HashSet<(Vector2Int, Vector2Int)>();
		foreach (KeyValuePair<Vector2Int, Room> placedRoom in placedRooms)
		{
			Vector2Int key = placedRoom.Key;
			Room value = placedRoom.Value;
			Vector2Int[] array = (Vector2Int[])(object)new Vector2Int[2]
			{
				Vector2Int.right,
				Vector2Int.up
			};
			foreach (Vector2Int val in array)
			{
				Vector2Int key2 = key + val;
				if (placedRooms.TryGetValue(key2, out Room value2))
				{
					Transform exitFacing = GetExitFacing(value, val);
					Transform exitFacing2 = GetExitFacing(value2, -val);
					if (!((Object)(object)exitFacing == (Object)null) && !((Object)(object)exitFacing2 == (Object)null) && Mathf.Abs(exitFacing.position.y - exitFacing2.position.y) <= 0.1f)
					{
						hashSet.Add((key, val));
					}
				}
			}
		}
		foreach (KeyValuePair<Vector2Int, Room> placedRoom2 in placedRooms)
		{
			Vector2Int key3 = placedRoom2.Key;
			Room value3 = placedRoom2.Value;
			HandleExit(value3, key3, Vector2Int.up, value3.exitTop);
			HandleExit(value3, key3, Vector2Int.down, value3.exitBottom);
			HandleExit(value3, key3, Vector2Int.left, value3.exitLeft);
			HandleExit(value3, key3, Vector2Int.right, value3.exitRight);
		}
		if ((Object)(object)MinimapUI.Instance != (Object)null)
		{
			MinimapUI.Instance.BuildMinimap(placedRooms, hashSet);
		}
	}

	private void HandleExit(Room room, Vector2Int pos, Vector2Int dir, Transform exit)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)exit == (Object)null)
		{
			return;
		}
		Vector2Int val = pos + dir;
		if (placedRooms.TryGetValue(val, out Room value))
		{
			Transform exitFacing = GetExitFacing(value, -dir);
			if ((Object)(object)exitFacing == (Object)null)
			{
				room.CreateWall(exit);
				return;
			}
			float num = Mathf.Abs(exit.position.y - exitFacing.position.y);
			if (num > 0.1f)
			{
				room.CreateWall(exit);
				Debug.LogWarning((object)$"[RoomGenerator] Exit mismatch at {pos} → {val} (ΔY={num:F2}) → wall placed.");
			}
			else if (IsSpecialRoomPriority(room.roomType, value.roomType) || (room.roomType == value.roomType && IsPrimary(pos, val)))
			{
				room.CreateDoor(exit);
			}
			else
			{
				room.DisableExit(exit);
			}
		}
		else
		{
			room.CreateWall(exit);
		}
	}

	private void Update()
	{
		if (_generationComplete && !(Time.time < _nextActivationCheck))
		{
			_nextActivationCheck = Time.time + 0.3f;
			UpdateRoomActivation();
			CheckOutOfBounds();
		}
	}

	private void UpdateRoomActivation()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: 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)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		NewMovement instance = MonoSingleton<NewMovement>.Instance;
		if ((Object)(object)instance == (Object)null)
		{
			return;
		}
		Vector2Int val = WorldToGrid(((Component)instance).transform.position);
		Vector2Int val2 = ((path.Count > 0) ? path[0] : Vector2Int.zero);
		foreach (KeyValuePair<Vector2Int, Room> placedRoom in placedRooms)
		{
			if (!((Object)(object)placedRoom.Value == (Object)null))
			{
				bool flag = placedRoom.Key == val2;
				Vector2Int key = placedRoom.Key;
				int num = Mathf.Abs(((Vector2Int)(ref key)).x - ((Vector2Int)(ref val)).x);
				key = placedRoom.Key;
				int num2 = num + Mathf.Abs(((Vector2Int)(ref key)).y - ((Vector2Int)(ref val)).y);
				bool flag2 = flag || num2 <= activationRadius;
				if (((Component)placedRoom.Value).gameObject.activeSelf != flag2)
				{
					((Component)placedRoom.Value).gameObject.SetActive(flag2);
				}
			}
		}
	}

	private void CheckOutOfBounds()
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		NewMovement instance = MonoSingleton<NewMovement>.Instance;
		if ((Object)(object)instance == (Object)null || _isTeleportingToErrorRoom)
		{
			return;
		}
		Vector2Int val = WorldToGrid(((Component)instance).transform.position);
		if (placedRooms.ContainsKey(val))
		{
			return;
		}
		GameObject val2 = GameObject.Find("ErrorRoom");
		if ((Object)(object)val2 != (Object)null)
		{
			float num = Vector3.Distance(((Component)instance).transform.position, val2.transform.position);
			if (num <= 100f)
			{
				return;
			}
		}
		if (canDoTheErrorRoom)
		{
			Debug.LogWarning((object)($"[RoomGenerator] Player is out of bounds at grid {val} " + $"(world {((Component)instance).transform.position}). Teleporting to ErrorRoom."));
			TeleportPlayerToErrorRoom(instance, val2);
		}
	}

	private void TeleportPlayerToErrorRoom(NewMovement player, GameObject errorRoom = null)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)errorRoom == (Object)null)
		{
			errorRoom = GameObject.Find("ErrorRoom");
		}
		if ((Object)(object)errorRoom == (Object)null)
		{
			Debug.LogError((object)"[RoomGenerator] Could not find a GameObject named 'ErrorRoom' to teleport the player to!");
			return;
		}
		_isTeleportingToErrorRoom = true;
		((Component)player).transform.position = errorRoom.transform.position;
		if ((Object)(object)player.rb != (Object)null)
		{
			player.rb.velocity = Vector3.zero;
		}
		Debug.Log((object)$"[RoomGenerator] Player teleported to ErrorRoom at {errorRoom.transform.position}.");
		Door[] array = Object.FindObjectsByType<Door>((FindObjectsInactive)1, (FindObjectsSortMode)0);
		Lockable lockable = default(Lockable);
		foreach (Door val in array)
		{
			if (!((Component)val).TryGetComponent<Lockable>(ref lockable) || !lockable.locked)
			{
				val.Unlock();
			}
		}
		_isTeleportingToErrorRoom = false;
	}

	private void EnforceEmptyRoomConnectivity()
	{
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		foreach (KeyValuePair<Vector2Int, Room> placedRoom in placedRooms)
		{
			Room value = placedRoom.Value;
			if (value.roomType != 0 || value.SpawnCredits != 0)
			{
				continue;
			}
			int num = 0;
			Vector2Int[] array = directions;
			foreach (Vector2Int val in array)
			{
				if (placedRooms.ContainsKey(placedRoom.Key + val))
				{
					num++;
				}
			}
			if (num < 2)
			{
				value.SpawnCredits = 3;
				Debug.Log((object)$"[RoomGenerator] Empty room at {placedRoom.Key} was a dead end — credits restored.");
			}
		}
	}

	public Vector2Int WorldToGrid(Vector3 worldPos)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		return new Vector2Int(Mathf.RoundToInt(worldPos.x / roomWidth), Mathf.RoundToInt(worldPos.z / roomHeight));
	}

	private bool IsSpecialRoomPriority(RoomType mine, RoomType theirs)
	{
		return mine != 0 && theirs == RoomType.Normal;
	}

	private bool IsPrimary(Vector2Int a, Vector2Int b)
	{
		return (((Vector2Int)(ref a)).x != ((Vector2Int)(ref b)).x) ? (((Vector2Int)(ref a)).x < ((Vector2Int)(ref b)).x) : (((Vector2Int)(ref a)).y < ((Vector2Int)(ref b)).y);
	}
}
[RequireComponent(typeof(Collider))]
public class RoomLinker : MonoBehaviour
{
	[Tooltip("The room script this trigger belongs to.")]
	public Room linkedRoom;

	private void Awake()
	{
		if ((Object)(object)linkedRoom == (Object)null)
		{
			linkedRoom = ((Component)((Component)this).transform.parent).GetComponent<Room>();
		}
	}

	private void OnTriggerEnter(Collider other)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		if (((Component)other).CompareTag("Player") && (Object)(object)MinimapUI.Instance != (Object)null && (Object)(object)linkedRoom != (Object)null)
		{
			MinimapUI.Instance.SetRoomOverride(linkedRoom.position);
		}
	}

	private void OnTriggerExit(Collider other)
	{
		if (((Component)other).CompareTag("Player") && (Object)(object)MinimapUI.Instance != (Object)null)
		{
			MinimapUI.Instance.SetRoomOverride(null);
		}
	}
}
public class SetCorrectLayerName : MonoBehaviour
{
	private void Awake()
	{
		((Component)this).GetComponent<LevelNameActivator>().levelName = $"FLOOR {RogueDifficultyManager.Instance.floor}";
	}
}
public class ShopItem : MonoBehaviour
{
	public BaseItem item;

	public int cost = 3;

	private bool purchased = false;

	private float messageCooldown = 0f;

	private TMP_Text price;

	private static readonly HashSet<BaseItem> s_reservedItems = new HashSet<BaseItem>();

	private static readonly HashSet<string> s_reservedWeapons = new HashSet<string>();

	private static int s_trackedFloor = -1;

	public static DropTable rationTable = new DropTable(new Dictionary<Rarity, float>
	{
		{
			Rarity.Common,
			0.25f
		},
		{
			Rarity.Uncommon,
			0.65f
		},
		{
			Rarity.Legendary,
			0.1f
		}
	});

	private static void TryResetForFloor()
	{
		int num = (((Object)(object)RogueDifficultyManager.Instance != (Object)null) ? RogueDifficultyManager.Instance.floor : 0);
		if (num != s_trackedFloor)
		{
			s_reservedItems.Clear();
			s_reservedWeapons.Clear();
			s_trackedFloor = num;
		}
	}

	private static BaseItem PickUniqueItem(DropTable table)
	{
		for (int i = 0; i < 30; i++)
		{
			BaseItem result = Plugin.GiveRandomItem(null, table);
			if (!s_reservedItems.Contains(result))
			{
				s_reservedItems.Add(result);
				return result;
			}
		}
		BaseItem result2 = Plugin.GiveRandomItem(null, table);
		s_reservedItems.Add(result2);
		return result2;
	}

	private static AWeapon PickUniqueWeapon()
	{
		for (int i = 0; i < 30; i++)
		{
			AWeapon aWeapon = AWeapon.GenerateWeapon();
			string text = $"{aWeapon.weapon}_{aWeapon.variant}_{aWeapon.Alternate}";
			if (!s_reservedWeapons.Contains(text))
			{
				s_reservedWeapons.Add(text);
				return aWeapon;
			}
		}
		AWeapon aWeapon2 = AWeapon.GenerateWeapon();
		s_reservedWeapons.Add($"{aWeapon2.weapon}_{aWeapon2.variant}_{aWeapon2.Alternate}");
		return aWeapon2;
	}

	private void Awake()
	{
		price = ((Component)this).GetComponentInChildren<TMP_Text>();
	}

	private int GetScaledCost(int baseCost)
	{
		int num = (((Object)(object)RogueDifficultyManager.Instance != (Object)null) ? RogueDifficultyManager.Instance.floor : 0);
		int num2 = num / 5;
		float num3 = Mathf.Pow(1.53f, (float)num2);
		return Mathf.CeilToInt((float)baseCost * num3);
	}

	private int getCost(Rarity rar)
	{
		int baseCost = 2;
		switch (rar)
		{
		case Rarity.Common:
			baseCost = 4;
			break;
		case Rarity.Uncommon:
			baseCost = 7;
			break;
		case Rarity.Legendary:
			baseCost = 12;
			break;
		}
		return GetScaledCost(baseCost);
	}

	private void Start()
	{
		TryResetForFloor();
		if ((float)RogueDifficultyManager.ItemRNG.NextDouble() >= 0.5f)
		{
			DropTable table = (((Object)((Component)this).gameObject).name.Contains("Ration") ? rationTable : null);
			BaseItem chosenItem = PickUniqueItem(table);
			cost = getCost(chosenItem.Rarity);
			price.text = $"${cost}";
			ItemPickup.CreatePickupConditional(chosenItem, ((Component)this).transform, delegate
			{
				RogueDifficultyManager instance4 = RogueDifficultyManager.Instance;
				if ((Object)(object)instance4 == (Object)null)
				{
					return false;
				}
				if (instance4.Gold >= cost)
				{
					purchased = true;
					instance4.Gold -= cost;
					HudMessageReceiver instance5 = MonoSingleton<HudMessageReceiver>.Instance;
					if (instance5 != null)
					{
						instance5.SendHudMessage($"Bought: {chosenItem}  (-{cost} gold)", "", "", 0, false, false, true);
					}
					return true;
				}
				if (messageCooldown <= 0f)
				{
					HudMessageReceiver instance6 = MonoSingleton<HudMessageReceiver>.Instance;
					if (instance6 != null)
					{
						instance6.SendHudMessage($"Need {cost} gold  (you have {instance4.Gold})", "", "", 0, false, false, true);
					}
					messageCooldown = 2f;
				}
				return false;
			});
			return;
		}
		AWeapon chosenWeapon = PickUniqueWeapon();
		int num = 5;
		num += RogueDifficultyManager.ItemRNG.Next(-1, 3);
		num = Mathf.Max(4, num);
		cost = GetScaledCost(num);
		price.text = $"${cost}";
		WeaponPickupRogue.CreatePickupConditional(((Component)this).transform, delegate
		{
			RogueDifficultyManager instance = RogueDifficultyManager.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			if (instance.Gold >= cost)
			{
				purchased = true;
				instance.Gold -= cost;
				HudMessageReceiver instance2 = MonoSingleton<HudMessageReceiver>.Instance;
				if (instance2 != null)
				{
					instance2.SendHudMessage($"Bought: {chosenWeapon}  (-{cost} gold)", "", "", 0, false, false, true);
				}
				return true;
			}
			if (messageCooldown <= 0f)
			{
				HudMessageReceiver instance3 = MonoSingleton<HudMessageReceiver>.Instance;
				if (instance3 != null)
				{
					instance3.SendHudMessage($"Need {cost} gold  (you have {instance.Gold})", "", "", 0, false, false, true);
				}
				messageCooldown = 2f;
			}
			return false;
		}, 2f, chosenWeapon);
	}

	private void Update()
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		if (!purchased)
		{
			if (messageCooldown > 0f)
			{
				messageCooldown -= Time.deltaTime;
			}
			if (!(Vector3.Distance(((Component)MonoSingleton<NewMovement>.Instance).transform.position, ((Component)this).transform.position) > 2f))
			{
			}
		}
	}

	public static ShopItem CreateShopItem(BaseItem item, Vector3 position, int cost = 3)
	{
		//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_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)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
		((Object)val).name = "ShopItem";
		val.GetComponent<Collider>().enabled = false;
		val.transform.position = position + Vector3.up * 2f;
		val.transform.localScale = Vector3.one * 0.55f;
		ApplyMaterial(val, new Color(1f, 0.82f, 0.1f));
		ShopItem shopItem = val.AddComponent<ShopItem>();
		shopItem.item = item;
		shopItem.cost = cost;
		int num = Mathf.Min(cost, 5);
		for (int i = 0; i < num; i++)
		{
			GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)val2).name = $"PricePip_{i}";
			val2.transform.SetParent(val.transform);
			val2.transform.localPosition = new Vector3(0f, 1.4f + (float)i * 0.35f, 0f);
			val2.transform.localScale = new Vector3(0.25f, 0.2f, 0.25f);
			val2.GetComponent<Collider>().enabled = false;
			ApplyMaterial(val2, new Color(0.9f, 0.15f, 0.1f));
		}
		return shopItem;
	}

	private static void ApplyMaterial(GameObject go, Color color)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		Renderer component = go.GetComponent<Renderer>();
		if (!((Object)(object)component == (Object)null))
		{
			Shader val = (((Object)(object)MonoSingleton<DefaultReferenceManager>.Instance != (Object)null) ? MonoSingleton<DefaultReferenceManager>.Instance.masterShader : Shader.Find("Standard"));
			component.material = new Material(val)
			{
				color = color
			};
		}
	}
}
public class ShopPortalStuff : MonoBehaviour
{
	[SerializeField]
	private Door DoorToRunSimpleOpenOverrideOn;

	[SerializeField]
	private string PortalExitFinder = "ShopPortalExit";

	[SerializeField]
	private string PortalExitSlot = "ShopHolders";

	[SerializeField]
	private bool TriggerOnAwake = true;

	[Tooltip("If null, will just do GetComponent to get it")]
	[SerializeField]
	private Portal PortalScript;

	private GameObject Exit;

	private Transform slot;

	private GameObject[] ForeignExit = (GameObject[])(object)new GameObject[2];

	private bool isOpen = false;

	private void Awake()
	{
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		if (TriggerOnAwake)
		{
			isOpen = false;
			if ((Object)(object)PortalScript == (Object)null)
			{
				PortalScript = ((Component)this).GetComponent<Portal>();
			}
			if (Object.op_Implicit((Object)(object)GameObject.Find(PortalExitFinder)))
			{
				Exit = Object.Instantiate<GameObject>(GameObject.Find(PortalExitFinder));
				slot = GameObject.Find(PortalExitSlot).transform;
				Exit.transform.parent = slot;
				Exit.transform.localPosition = Vector3.zero;
				((Component)((Component)PortalScript.exit).transform).gameObject.GetComponent<Follow>().target = Exit.transform;
			}
		}
	}

	public void Fake()
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Expected O, but got Unknown
		Exit.transform.localPosition = Vector3.zero;
		if ((Object)(object)ForeignExit[0] == (Object)null)
		{
			int num = 0;
			foreach (Transform item in slot)
			{
				Transform val = item;
				if ((Object)(object)val != (Object)(object)Exit.transform)
				{
					ForeignExit[num++] = ((Component)val).gameObject;
				}
			}
		}
		GameObject[] foreignExit = ForeignExit;
		foreach (GameObject val2 in foreignExit)
		{
			if (!((Object)(object)val2 == (Object)null))
			{
				val2.transform.localPosition = new Vector3(0f, -50f, 0f);
			}
		}
	}

	private void Open()
	{
		if (!DoorToRunSimpleOpenOverrideOn.open)
		{
			DoorToRunSimpleOpenOverrideOn.SimpleOpenOverride();
		}
	}

	private void Update()
	{
		if (Plugin.GetItemCount("Ration Card") > 0)
		{
			Open();
		}
	}
}
public static class UtilsRogue
{
	private static Font _gameFont;

	private static Sprite _levelPanel;

	private static Sprite _hellmapArrow;

	private static Material _metalDec20;

	public static Font gameFont
	{
		get
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_gameFont == (Object)null)
			{
				_gameFont = Addressables.LoadAssetAsync<Font>((object)"Assets/Fonts/VCR_OSD_MONO_1.001.ttf").WaitForCompletion();
			}
			return _gameFont;
		}
	}

	public static Sprite levelPanel
	{
		get
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_levelPanel == (Object)null)
			{
				_levelPanel = Addressables.LoadAssetAsync<Sprite>((object)"Assets/Textures/UI/meter.png").WaitForCompletion();
			}
			return _levelPanel;
		}
	}

	public static Sprite hellmapArrow
	{
		get
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_hellmapArrow == (Object)null)
			{
				_hellmapArrow = Addressables.LoadAssetAsync<Sprite>((object)"Assets/Textures/UI/arrow.png").WaitForCompletion();
			}
			return _hellmapArrow;
		}
	}

	public static Material metalDec20
	{
		get
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_metalDec20 == (Object)null)
			{
				_metalDec20 = Addressables.LoadAssetAsync<Material>((object)"Assets/Materials/Environment/Metal/Metal Decoration 20.mat").WaitForCompletion();
			}
			return _metalDec20;
		}
	}

	public static void SetPlayerWorldRotation(Quaternion newRotation)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		((Component)MonoSingleton<CameraController>.Instance).transform.rotation = newRotation;
		float x = ((Component)MonoSingleton<CameraController>.Instance).transform.localEulerAngles.x;
		float rotationX = x;
		if (x <= 90f && x >= 0f)
		{
			rotationX = 0f - x;
		}
		else if (x >= 270f && x <= 360f)
		{
			rotationX = Mathf.Lerp(0f, 90f, Mathf.InverseLerp(360f, 270f, x));
		}
		Quaternion rotation = ((Component)MonoSingleton<CameraController>.Instance).transform.rotation;
		float y = ((Quaternion)(ref rotation)).eulerAngles.y;
		MonoSingleton<CameraController>.Instance.rotationX = rotationX;
		MonoSingleton<CameraController>.Instance.rotationY = y;
	}
}
public static class UnityUtilsRogue
{
	[CompilerGenerated]
	private sealed class <GetComponentsInChildrenRecursive>d__0<T> : IEnumerable<object>, IEnumerable, IEnumerator<object>, IEnumerator, IDisposable where T : notnull, Component
	{
		private int <>1__state;

		private object <>2__current;

		private int <>l__initialThreadId;

		private Transform parent;

		public Transform <>3__parent;

		private IEnumerator <>s__1;

		private Transform <child>5__2;

		private T <comp>5__3;

		private IEnumerator <>s__4;

		private T <childComp>5__5;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <GetComponentsInChildrenRecursive>d__0(int <>1__state)
		{
			this.<>1__state = <>1__state;
			<>l__initialThreadId = Environment.CurrentManagedThreadId;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if ((uint)(num - -4) <= 1u || (uint)(num - 1) <= 1u)
			{
				try
				{
					if (num == -4 || num == 2)
					{
						try
						{
						}
						finally
						{
							<>m__Finally2();
						}
					}
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<>s__1 = null;
			<child>5__2 = null;
			<comp>5__3 = default(T);
			<>s__4 = null;
			<childComp>5__5 = default(T);
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>s__1 = parent.GetEnumerator();
					<>1__state = -3;
					goto IL_013b;
				case 1:
					<>1__state = -3;
					goto IL_00a5;
				case 2:
					{
						<>1__state = -4;
						<childComp>5__5 = default(T);
						goto IL_010c;
					}
					IL_013b:
					if (<>s__1.MoveNext())
					{
						<child>5__2 = (Transform)<>s__1.Current;
						if (((Component)<child>5__2).TryGetComponent<T>(ref <comp>5__3))
						{
							<>2__current = <comp>5__3;
							<>1__state = 1;
							return true;
						}
						goto IL_00a5;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
					IL_00a5:
					<>s__4 = GetComponentsInChildrenRecursive<T>(<child>5__2).GetEnumerator();
					<>1__state = -4;
					goto IL_010c;
					IL_010c:
					if (<>s__4.MoveNext())
					{
						<childComp>5__5 = (T)<>s__4.Current;
						<>2__current = <childComp>5__5;
						<>1__state = 2;
						return true;
					}
					<>m__Finally2();
					<>s__4 = null;
					<comp>5__3 = default(T);
					<child>5__2 = null;
					goto IL_013b;
				}
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			if (<>s__1 is IDisposable disposable)
			{
				disposable.Dispose();
			}
		}

		private void <>m__Finally2()
		{
			<>1__state = -3;
			if (<>s__4 is IDisposable disposable)
			{
				disposable.Dispose();
			}
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}

		[DebuggerHidden]
		IEnumerator<object> IEnumerable<object>.GetEnumerator()
		{
			<GetComponentsInChildrenRecursive>d__0<T> <GetComponentsInChildrenRecursive>d__;
			if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
			{
				<>1__state = 0;
				<GetComponentsInChildrenRecursive>d__ = this;
			}
			else
			{
				<GetComponentsInChildrenRecursive>d__ = new <GetComponentsInChildrenRecursive>d__0<T>(0);
			}
			<GetComponentsInChildrenRecursive>d__.parent = <>3__parent;
			return <GetComponentsInChildrenRecursive>d__;
		}

		[DebuggerHidden]
		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable<object>)this).GetEnumerator();
		}
	}

	[IteratorStateMachine(typeof(<GetComponentsInChildrenRecursive>d__0<>))]
	public static IEnumerable GetComponentsInChildrenRecursive<T>(Transform parent) where T : Component
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <GetComponentsInChildrenRecursive>d__0<T>(-2)
		{
			<>3__parent = parent
		};
	}

	public static T GetComponentInChildrenRecursive<T>(Transform parent) where T : Component
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		T result = default(T);
		foreach (Transform item in parent)
		{
			Transform val = item;
			if (((Component)val).TryGetComponent<T>(ref result))
			{
				return result;
			}
			T componentInChildrenRecursive = GetComponentInChildrenRecursive<T>(val);
			if ((Object)(object)componentInChildrenRecursive != (Object)null)
			{
				return componentInChildrenRecursive;
			}
		}
		return default(T);
	}
}
namespace Ultrarogue
{
	public static class BundleLoader
	{
		private static bool alrLoaded;

		public static string EpicScene => Path.Combine(Application.temporaryCachePath, "Ultrarogue");

		public static void Load()
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			if (alrLoaded)
			{
				return;
			}
			if (Directory.Exists(EpicScene))
			{
				Directory.Delete(EpicScene, recursive: true);
			}
			Directory.CreateDirectory(EpicScene);
			Addressables.ResourceManager.InternalIdTransformFunc = delegate(IResourceLocation location)
			{
				string internalId = location.InternalId;
				return internalId.Contains("Ultrarogue.Bundleloader.EpicScene") ? internalId.Replace("Ultrarogue.Bundleloader.EpicScene", EpicScene) : internalId;
			};
			Assembly assembly = typeof(Plugin).Assembly;
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				string path = (text.StartsWith("Ultrarogue.catalogStuff.") ? text.Substring("Ultrarogue.catalogStuff.".Length) : text);
				string path2 = Path.Combine(EpicScene, path);
				using Stream stream = assembly.GetManifestResourceStream(text);
				using FileStream destination = File.Create(path2);
				stream.CopyTo(destination);
			}
			Addressables.LoadContentCatalogAsync(Path.Combine(EpicScene, "catalog.json"), true, (string)null).WaitForCompletion();
			alrLoaded = true;
		}
	}
	[BepInPlugin("com.bananastudio.ultrarogue", "My first plugin", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public enum Weapon
		{
			Revolver,
			Shotgun,
			Nailgun,
			Railcannon,
			RocketLauncher,
			Arm
		}

		public enum Variant
		{
			Blue,
			Green,
			Red
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass47_0
		{
			public AsyncOperationHandle<GameObject> RogueButtonPref;

			public AsyncOperationHandle<GameObject> RogueMenu;

			public TMP_InputField seedField;

			public Plugin <>4__this;

			public TMP_Text info;

			public TMP_Text cName;

			public GameObject men;

			internal bool <SpawnThings>b__0()
			{
				return RogueButtonPref.IsDone;
			}

			internal bool <SpawnThings>b__2()
			{
				return RogueMenu.IsDone;
			}

			internal void <SpawnThings>b__3()
			{
				if (SelectedChar == null)
				{
					Logger.LogError((object)"[Play] SelectedChar is null!");
				}
				else
				{
					LoadLevel(seedField.text);
				}
			}

			internal void <SpawnThings>b__4()
			{
				<>4__this.Previous(info, cName);
			}

			internal void <SpawnThings>b__5()
			{
				<>4__this.Next(info, cName);
			}

			internal void <SpawnThings>b__6()
			{
				men.SetActive(true);
				GameObject.Find("Chapter Select").SetActive(false);
			}

			internal void <SpawnThings>b__7()
			{
				((Component)men.transform.Find("Back").parent.parent.Find("Chapter Select")).gameObject.SetActive(true);
				men.SetActive(false);
			}
		}

		[CompilerGenerated]
		private sealed class <SpawnThings>d__47 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			private <>c__DisplayClass47_0 <>8__1;

			private GameObject <parent>5__2;

			private GameObject <but>5__3;

			private GameObject <parentMen>5__4;

			private Button <lBut>5__5;

			private Button <rBut>5__6;

			private Button <butt>5__7;

			private TMP_Dropdown <drop>5__8;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SpawnThings>d__47(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<parent>5__2 = null;
				<but>5__3 = null;
				<parentMen>5__4 = null;
				<lBut>5__5 = null;
				<rBut>5__6 = null;
				<butt>5__7 = null;
				<drop>5__8 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Expected O, but got Unknown
				//IL_028f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0299: Expected O, but got Unknown
				//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03db: Expected O, but got Unknown
				//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_03fd: Expected O, but got Unknown
				//IL_0415: Unknown result type (might be due to invalid IL or missing references)
				//IL_041f: Expected O, but got Unknown
				//IL_0450: Unknown result type (might be due to invalid IL or missing references)
				//IL_045a: Expected O, but got Unknown
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass47_0();
					<>8__1.<>4__this = <>4__this;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Logger.LogInfo((object)$"I have reset difficulty to {CurrentDifficulty}");
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>8__1.RogueButtonPref = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Modding/RogueMode/RogueMode.prefab");
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.RogueButtonPref.IsDone));
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<parent>5__2 = ((IEnumerable<GameObject>)Object.FindObjectsByType<GameObject>((FindObjectsInactive)1, (FindObjectsSortMode)0)).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => ((Object)x).name.Contains((!IsOtherModLoaded()) ? "Chapters" : "TopRightChapterSelect")));
					if ((Object)(object)<parent>5__2 == (Object)null)
					{
						Logger.LogError((object)"[SpawnThings] Could not find a GameObject whose name contains 'Chapters'. Aborting.");
						return false;
					}
					<but>5__3 = Object.Instantiate<GameObject>(<>8__1.RogueButtonPref.Result, <parent>5__2.transform);
					((Component)<but>5__3.transform.Find("RankPanel/RankText")).GetComponent<TMP_Text>().text = <>4__this.GetBest().BestRun.Floor.ToString();
					<>8__1.RogueMenu = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Modding/RogueMode/RogueMenu.prefab");
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.RogueMenu.IsDone));
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<parentMen>5__4 = ((Component)Object.FindObjectOfType<OptionsMenuToManager>()).gameObject;
					<>8__1.men = Object.Instantiate<GameObject>(<>8__1.RogueMenu.Result, <parentMen>5__4.transform);
					<>8__1.men.SetActive(false);
					<>8__1.seedField = ((Component)<>8__1.men.transform.Find("SeedField")).GetComponent<TMP_InputField>();
					((UnityEvent)((Component)<>8__1.men.transform.Find("Play")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						if (SelectedChar == null)
						{
							Logger.LogError((object)"[Play] SelectedChar is null!");
						}
						else
						{
							LoadLevel(<>8__1.seedField.text);
						}
					});
					<>8__1.info = ((Component)<>8__1.men.transform.Find("Info/InfoText")).GetComponent<TMP_Text>();
					<>8__1.cName = ((Component)<>8__1.men.transform.Find("Info/CharName")).GetComponent<TMP_Text>();
					<lBut>5__5 = ((Component)<>8__1.men.transform.Find("Info/LeftButt")).GetComponent<Button>();
					<rBut>5__6 = ((Component)<>8__1.men.transform.Find("Info/LeftButt (1)")).GetComponent<Button>();
					<butt>5__7 = <but>5__3.GetComponent<Button>();
					SelectedChar = characters[0];
					<>4__this.currentIndex = 0;
					<>8__1.info.text = SelectedChar.Description;
					((Component)<>8__1.info).GetComponent<ScrollingText>().message = SelectedChar.Description;
					<>8__1.cName.text = SelectedChar.Name;
					((UnityEvent)<lBut>5__5.onClick).AddListener((UnityAction)delegate
					{
						<>8__1.<>4__this.Previous(<>8__1.info, <>8__1.cName);
					});
					((UnityEvent)<rBut>5__6.onClick).AddListener((UnityAction)delegate
					{
						<>8__1.<>4__this.Next(<>8__1.info, <>8__1.cName);
					});
					((UnityEvent)<butt>5__7.onClick).AddListener((UnityAction)delegate
					{
						<>8__1.men.SetActive(true);
						GameObject.Find("Chapter Select").SetActive(false);
					});
					((UnityEvent)((Component)<>8__1.men.transform.Find("Back")).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						((Component)<>8__1.men.transform.Find("Back").parent.parent.Find("Chapter Select")).gameObject.SetActive(true);
						<>8__1.men.SetActive(false);
					});
					<drop>5__8 = ((Component)<>8__1.men.transform.Find("Info/Dropdown")).gameObject.GetComponent<TMP_Dropdown>();
					((UnityEvent<int>)(object)<drop>5__8.onValueChanged).AddListener((UnityAction<int>)delegate(int i)
					{
						CurrentDifficulty = i + 1;
						Logger.LogInfo((object)$"Difficulty is {CurrentDifficulty}");
					});
					CurrentDifficulty = 1;
					if (userHasIncomaptibleMods())
					{
						Logger.LogInfo((object)"AAAAAAAAA INCOMPATIBLE MOD DETECTEDDD");
						((Component)<>8__1.men.transform.Find("IncomModsMessage")).gameObject.SetActive(true);
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <SwitchToNewWeapon>d__55 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AWeapon weapon;

			private int <slot>5__1;

			private int <variantIndex>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SwitchToNewWeapon>d__55(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)MonoSingleton<GunControl>.Instance == (Object)null)
					{
						return false;
					}
					<slot>5__1 = WeaponToSlot(weapon.weapon);
					if (<slot>5__1 < 0)
					{
						return false;
					}
					<variantIndex>5__2 = (int)weapon.variant;
					MonoSingleton<GunControl>.Instance.SwitchWeapon(<slot>5__1, (int?)<variantIndex>5__2, false, false, false);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Harmony Harmony = new Harmony("com.bananastudio.ultrarogue");

		public static List<DeathEffect> deathEffects = new List<DeathEffect>();

		public static List<HitEffect> hitEffects = new List<HitEffect>();

		public static List<DamageModifier> dmgModifiers = new List<DamageModifier>();

		public static List<BaseItem> possibleItems = new List<BaseItem>();

		public static Dictionary<BaseItem, int> items = new Dictionary<BaseItem, int>();

		public static Dictionary<string, BaseItem> nameToItem = new Dictionary<string, BaseItem>();

		public static List<PlayerChange> playerChanges = new List<PlayerChange>();

		public static List<AWeapon> weapons = new List<AWeapon>();

		public static List<BaseCharacter> characters = new List<BaseCharacter>();

		public static string GameSeed = "Banana";

		public static bool RogueMode = false;

		public float normalMoveSpeed = 0f;

		private float normalJumpHeight = 0f;

		public static int MaxHealth = 100;

		public static Change AttackSpeed;

		public static Change cooldownReduction = new Change();

		public static BaseCharacter SelectedChar = null;

		private int currentIndex;

		public static int CurrentDifficulty;

		private static List<string> inComMods = new List<string> { "billy.spawnerarmextras" };

		public static DropTable testTable = new DropTable(new Dictionary<Rarity, float>
		{
			{
				Rarity.Common,
				0.8f
			},
			{
				Rarity.Uncommon,
				0.15f
			},
			{
				Rarity.Legendary,
				0.05f
			}
		});

		public static Change globalDamageMult;

		public static Dictionary<Weapon, Change> damageMultipliers = new Dictionary<Weapon, Change>
		{
			{
				Weapon.Revolver,
				new Change()
			},
			{
				Weapon.Shotgun,
				new Change()
			},
			{
				Weapon.Nailgun,
				new Change()
			},
			{
				Weapon.Railcannon,
				new Change()
			},
			{
				Weapon.RocketLauncher,
				new Change()
			},
			{
				Weapon.Arm,
				new Change()
			}
		};

		public static int luck = 0;

		private static Dictionary<string, float> procCoeffiecents = new Dictionary<string, float>
		{
			{ "nail", 0.25f },
			{ "chainsawprojectile", 0.55f },
			{ "sawblade", 0.75f },
			{ "shotgun", 0.25f },
			{ "railcannon", 0.8f },
			{ "drill", 0.25f }
		};

		internal static ManualLogSource Logger { get; private set; } = null;


		public static Plugin Instance { get; private set; }

		public static string getWeaponString(Weapon weapon, Variant variant)
		{
			string weaponString = getWeaponString(weapon);
			int num = (int)variant;
			return "weapon." + weaponString + num;
		}

		public static string getWeaponString(Weapon weapon)
		{
			return weapon switch
			{
				Weapon.Revolver => "rev", 
				Weapon.Shotgun => "sho", 
				Weapon.Nailgun => "nai", 
				Weapon.Railcannon => "rai", 
				Weapon.RocketLauncher => "rock", 
				Weapon.Arm => "arm", 
				_ => "i dont fucking know????", 
			};
		}

		public static bool isInRogueMode()
		{
			return RogueMode;
		}

		public static bool isInRogueScene()
		{
			return SceneHelper.CurrentScene == "Ultrarogue";
		}

		public static BaseItem getItem(string name)
		{
			if (!nameToItem.ContainsKey(name))
			{
				return null;
			}
			return nameToItem[name];
		}

		public static int GetItemCount(string name)
		{
			BaseItem item = getItem(name);
			if (item == null)
			{
				return 0;
			}
			if (items.ContainsKey(item))
			{
				return items[item];
			}
			return 0;
		}

		public static int GetItemCount(BaseItem item)
		{
			if (item == null)
			{
				return 0;
			}
			if (items.ContainsKey(item))
			{
				return items[item];
			}
			return 0;
		}

		private void Awake()
		{
			CurrentDifficulty = 1;
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin com.bananastudio.ultrarogue is loaded!");
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)4;
			Harmony.PatchAll();
			GatherItems();
			SceneManager.sceneLoaded += SceneManager_sceneLoaded;
			weapons.Clear();
			weapons.Add(new AWeapon(Weapon.Revolver, Variant.Blue));
			weapons.Add(new AWeapon(Weapon.Arm, Variant.Blue));
			AssetsManager.Init();
			BundleLoader.Load();
			characters.Add(new V1());
			characters.Add(new V2());
			characters.Add(new Streetcleaner());
			characters.Add(new RandomCharacter());
		}

		private void Next(TMP_Text info, TMP_Text name)
		{
			if (characters.Count != 0)
			{
				currentIndex++;
				if (currentIndex >= characters.Count)
				{
					currentIndex = 0;
				}
				UpdateState(info, name);
			}
		}

		private void Previous(TMP_Text info, TMP_Text name)
		{
			if (characters.Count != 0)
			{
				currentIndex--;
				if (currentIndex < 0)
				{
					currentIndex = characters.Count - 1;
				}
				UpdateState(info, name);
			}
		}

		private void UpdateState(TMP_Text info, TMP_Text name)
		{
			SelectedChar = characters[currentIndex];
			info.text = SelectedChar.Name;
			((Component)info).GetComponent<ScrollingText>().message = SelectedChar.Description;
			((Component)info).GetComponent<ScrollingText>().activated = true;
			((MonoBehaviour)this).StartCoroutine(((Component)info).GetComponent<ScrollingText>().PrepText());
			name.text = SelectedChar.Name;
		}

		private RogueSaveData GetBest()
		{
			string @string = PlayerPrefs.GetString("RogueModeBest", "");
			RogueSaveData rogueSaveData = JsonConvert.DeserializeObject<RogueSaveData>(@string);
			RogueSaveData rogueSaveData2 = new RogueSaveData();
			if (rogueSaveData == null)
			{
				rogueSaveData2.datas = new List<RogueSaveDataData>();
				rogueSaveData2.BestRun = new RogueSaveDataData();
			}
			else
			{
				rogueSaveData2 = rogueSaveData;
			}
			return rogueSaveData2;
		}

		public static string GenerateRandomString(int length)
		{
			char[] value = (from _ in Enumerable.Range(0, length)
				select "abcdefghijklmnopqrstuvwxyz0123456789"[Random.Range(0, "abcdefghijklmnopqrstuvwxyz0123456789".Length)]).ToArray();
			return new string(value).ToUpper();
		}

		public static void LoadLevel(string seed)
		{
			if (string.IsNullOrEmpty(seed))
			{
				GameSeed = GenerateRandomString(6);
			}
			else
			{
				GameSeed = seed;
			}
			SelectedChar.OnRunStart();
			foreach (KeyValuePair<BaseItem, int> item in items)
			{
				item.Key.OnGotten(0, firstPickup: false);
				item.Key.OnUpdate(0);
				item.Key.OnRemoval();
			}
			items.Clear();
			weapons.Clear();
			if (SelectedChar.StartingWeapons == null || SelectedChar.StartingWeapons.Count == 0)
			{
				Logger.LogWarning((object)("[Play] " + SelectedChar.Name + " has no StartingWeapons — falling back to defaults."));
				weapons.Add(new AWeapon(Weapon.Revolver, Variant.Blue));
				weapons.Add(new AWeapon(Weapon.Arm, Variant.Blue));
			}
			else
			{
				weapons.AddRange(SelectedChar.StartingWeapons);
			}
			Logger.LogInfo((object)("Item count: " + SelectedChar.StartingItems.Count));
			if (SelectedChar.StartingItems.Count != 0)
			{
				foreach (string startingItem in SelectedChar.StartingItems)
				{
					Logger.LogInfo((object)("Giving item: " + startingItem));
					GiveItem(startingItem);
				}
			}
			((MonoBehaviour)Instance).StartCoroutine(SceneLoader.LoadLevelAsync(noSplash: false));
		}

		public static bool userHasIncomaptibleMods()
		{
			foreach (string key in Chainloader.PluginInfos.Keys)
			{
				Logger.LogInfo((object)("Loaded plugin GUID: " + key));
			}
			foreach (string inComMod in inComMods)
			{
				Logger.LogInfo((object)("Checking mod: " + inComMod));
				if (Chainloader.PluginInfos.ContainsKey(inComMod))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsOtherModLoaded()
		{
			return Chainloader.PluginInfos.ContainsKey("duviz.ultrakill.ultraeditor");
		}

		[IteratorStateMachine(typeof(<SpawnThings>d__47))]
		private IEnumerator SpawnThings()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnThings>d__47(0)
			{
				<>4__this = this
			};
		}

		private void SceneManager_sceneLoaded(Scene arg0, LoadSceneMode arg1)
		{
			if (Object.op_Implicit((Object)(object)Object.FindObjectOfType<RogueDifficultyManager>()))
			{
				RogueMode = true;
			}
			else
			{
				RogueMode = false;
			}
			if (SceneHelper.CurrentScene == "Main Menu")
			{
				if (!AssetsManager.IsReady)
				{
					AssetsManager.Init();
				}
				((MonoBehaviour)this).StartCoroutine(SpawnThings());
			}
			else
			{
				foreach (KeyValuePair<BaseItem, int> item in items)
				{
					item.Key.OnGotten(0, firstPickup: false);
				}
				items.Clear();
			}
			if (!((Object)(object)MonoSingleton<NewMovement>.Instance == (Object)null))
			{
				normalMoveSpeed = MonoSingleton<NewMovement>.Instance.walkSpeed;
				normalJumpHeight = MonoSingleton<NewMovement>.Instance.jumpPower;
			}
		}

		private void Update()
		{
			foreach (BaseCharacter character in characters)
			{
				character.Update(SelectedChar == character);
			}
			foreach (KeyValuePair<BaseItem, int> item in items)
			{
				item.Key.OnUpdate(item.Value);
			}
			ApplyPlayerChanges();
			ApplyWeaponSpeeds();
		}

		private void ApplyWeaponSpeeds()
		{
			if (!((Object)(object)MonoSingleton<NewMovement>.Instance == (Object)null))
			{
				Animator[] componentsInChildren = ((Component)MonoSingleton<NewMovement>.Instance).GetComponentsInChildren<Animator>();
				foreach (Animator val in componentsInChildren)
				{
					val.speed = AttackSpeed.CalculateChanges(1f);
				}
			}
		}

		private void ApplyPlayerChanges()
		{
			if ((Object)(object)MonoSingleton<NewMovement>.Instance == (Object)null)
			{
				return;
			}
			Change change = new Change();
			Change change2 = new Change();
			Change change3 = new Change();
			Change change4 = new Change();
			Change change5 = new Change();
			Change change6 = new Change();
			Dictionary<Weapon, DamageChange> dictionary = new Dictionary<Weapon, DamageChange>();
			foreach (PlayerChange playerChange in playerChanges)
			{
				change.ApplyChangeToChange(playerChange.moveSpeed);
				change2.ApplyChangeToChange(playerChange.jumpHeight);
				change3.ApplyChangeToChange(playerChange.maxHealth);
				change4.ApplyChangeToChange(playerChange.attackSpeed);
				change6.ApplyChangeToChange(playerChange.cooldownRed);
				change5.ApplyChangeToChange(playerChange.globalDamageMult);
				foreach (DamageChange damageChange2 in playerChange.damageChanges)
				{
					if (!dictionary.ContainsKey(damageChange2.WeaponType))
					{
						dictionary.Add(damageChange2.WeaponType, new DamageChange(damageChange2.WeaponType, new Change()));
					}
					DamageChange damageChange = dictionary[damageChange2.WeaponType];
					damageChange.damageChange.ApplyChangeToChange(damageChange2.damageChange);
				}
			}
			MonoSingleton<NewMovement>.Instance.walkSpeed = change.CalculateChanges(normalMoveSpeed);
			MonoSingleton<NewMovement>.Instance.jumpPower = change2.CalculateChanges(normalJumpHeight);
			globalDamageMult = change5;
			MaxHealth = Mathf.RoundToInt(change3.CalculateChanges(100f));
			AttackSpeed = change4;
			cooldownReduction = change6;
			foreach (Weapon item in damageMultipliers.Keys.ToList())
			{
				damageMultipliers[item] = new Change();
			}
			foreach (KeyValuePair<Weapon, DamageChange> item2 in dictionary)
			{
				damageMultipliers[item2.Key] = item2.Value.damageChange;
			}
		}

		public static float LogarithmicChance(int stacks, float scaling, float startValue, float maxValue)
		{
			return startValue + (maxValue - startValue) * (1f - Mathf.Exp((0f - scaling) * (float)stacks));
		}

		public static void AddWeapon(AWeapon weapon)
		{
			AWeapon weapon2 = weapon;
			weapons.RemoveAll((AWeapon w) => w.weapon == weapon2.weapon && w.variant == weapon2.variant);
			weapons.Add(weapon2);
			if (weapon2.weapon == Weapon.Arm)
			{
				MonoSingleton<FistControl>.Instance.ResetFists();
				if (weapon2.variant != Variant.Green)
				{
					MonoSingleton<FistControl>.Instance.ArmChange((weapon2.variant == Variant.Red) ? 1 : 0);
				}
			}
			else
			{
				MonoSingleton<GunSetter>.Instance.ResetWeapons(false);
				((MonoBehaviour)Instance).StartCoroutine(SwitchToNewWeapon(weapon2));
			}
		}

		[IteratorStateMachine(typeof(<SwitchToNewWeapon>d__55))]
		private static IEnumerator SwitchToNewWeapon(AWeapon weapon)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SwitchToNewWeapon>d__55(0)
			{
				weapon = weapon
			};
		}

		private static int WeaponToSlot(Weapon weapon)
		{
			return weapon switch
			{
				Weapon.Revolver => 1, 
				Weapon.Shotgun => 2, 
				Weapon.Nailgun => 3, 
				Weapon.Railcannon => 4, 
				Weapon.RocketLauncher => 5, 
				Weapon.Arm => 6, 
				_ => -1, 
			};
		}

		public static List<BaseItem> getRarityItems(Rarity rarity)
		{
			return possibleItems.Where((BaseItem x) => x.Rarity == rarity && (!SelectedChar.HasPassive(Passive.HealFromBlood) || !x.itemTags.Contains(ItemTag.Healing)) && (x.ItemName != "Gasoline" || SelectedChar.GetType() == typeof(Streetcleaner)) && (x.WeaponRequirements.Count == 0 || x.WeaponRequirements.Any((Weapon req) => weapons.Any((AWeapon w) => w.weapon == req))) && (!x.CanOnlyHaveOne || GetItemCount(x) <= 0) && (x.ItemName != "Thunder Boomerang" || weapons.Any((AWeapon w) => w.weapon == Weapon.Revolver && w.variant == Variant.Green))).ToList();
		}

		public static Rarity getRarityBasedOnDropTable(DropTable table, Random rng)
		{
			float num = (float)rng.NextDouble();
			float num2 = 0f;
			foreach (KeyValuePair<Rarity, float> weight in table.weights)
			{
				num2 += weight.Value;
				if (num < num2)
				{
					return weight.Key;
				}
			}
			return table.weights.Keys.Last();
		}

		public static BaseItem GiveRandomItem(Random rng = null, DropTable table = null)
		{
			if (table == null)
			{
				table = testTable;
			}
			if (rng == null)
			{
				rng = RogueDifficultyManager.ItemRNG;
			}
			List<BaseItem> rarityItems = getRarityItems(getRarityBasedOnDropTable(testTable, rng));
			return rarityItems[rng.Next(0, rarityItems.Count)];
		}

		public static void GiveItem(BaseItem item)
		{
			if (items.ContainsKey(item))
			{
				items[item]++;
				item.OnGotten(items[item], firstPickup: false);
			}
			else
			{
				items.Add(item, 1);
				item.OnGotten(items[item], firstPickup: true);
			}
			if ((Object)(object)RogueDifficultyManager.Instance != (Object)null)
			{
				RogueDifficultyManager.Instance.AddItem(item);
			}
		}

		public static void GiveItem(string name)
		{
			BaseItem item = getItem(name);
			GiveItem(item);
		}

		public void GatherItems()
		{
			possibleItems = (from t in Assembly.GetExecutingAssembly().GetTypes()
				where typeof(BaseItem).IsAssignableFrom(t) && t != typeof(BaseItem) && !t.IsAbstract
				select (BaseItem)Activator.CreateInstance(t)).ToList();
			foreach (BaseItem possibleItem in possibleItems)
			{
				Logger.LogInfo((object)possibleItem);
				nameToItem.Add(possibleItem.ItemName, possibleItem);
				possibleItem.OnStart();
			}
			Logger.LogInfo((object)$"Items registered: {possibleItems.Count}");
		}

		public static Weapon HitterToWeapon(string hitter)
		{
			switch (hitter)
			{
			case "revolver":
				return Weapon.Revolver;
			case "shotgun":
			case "shotgunzone":
				return Weapon.Shotgun;
			case "nail":
			case "sawblade":
				return Weapon.Nailgun;
			case "explosion":
				return Weapon.RocketLauncher;
			case "railcannon":
			case "drill":
				return Weapon.Railcannon;
			case "punch":
			case "heavypunch":
				return Weapon.Arm;
			default:
				return (Weapon)100;
			}
		}

		public static List<string> WeaponToHitter(Weapon weapon)
		{
			List<string> list = new List<string>();
			switch (weapon)
			{
			case Weapon.Revolver:
				list.Add("revolver");
				break;
			case Weapon.Shotgun:
				list.Add("shotgun");
				list.Add("shotgunzone");
				break;
			case Weapon.Nailgun:
				list.Add("sawblade");
				list.Add("nail");
				break;
			case Weapon.RocketLauncher:
				list.Add("explosion");
				break;
			case Weapon.Railcannon:
				list.Add("railcannon");
				list.Add("drill");
				break;
			case Weapon.Arm:
				list.Add("punch");
				list.Add("heavypunch");
				break;
			default:
				list.Add("none");
				break;
			}
			return list;
		}

		public static float getChanceVal(bool luckaffected = true)
		{
			float num = Random.value;
			for (int i = 0; i < luck; i++)
			{
				float value = Random.value;
				if (value > num)
				{
					num = value;
				}
			}
			return num;
		}

		public static bool canExecute(float chance, string hitter, bool luckaffected = true)
		{
			float num = Random.value;
			for (int i = 0; i < luck; i++)
			{
				float value = Random.value;
				if (value > num)
				{
					num = value;
				}
			}
			if (procCoeffiecents.ContainsKey(hitter))
			{
				chance *= procCoeffiecents[hitter];
			}
			if (num <= chance / 100f)
			{
				return true;
			}
			return false;
		}

		private void OnGUI()
		{
			if (!((Object)(object)MonoSingleton<NewMovement>.Instance == (Object)null))
			{
			}
		}
	}
	public enum Rarity
	{
		Common,
		Uncommon,
		Legendary
	}
	public enum Team
	{
		Player,
		Enemies
	}
	public class TeamComponent : MonoBehaviour
	{
		public Team teamId = Team.Player;
	}
	public class AWeapon
	{
		public Plugin.Weapon weapon;

		public Plugin.Variant variant;

		public bool Alternate;

		public static AWeapon GenerateWeapon()
		{
			for (int i = 0; i < 50; i++)
			{
				AWeapon generated;
				if (Plugin.SelectedChar != null && Plugin.SelectedChar.GetType() == typeof(Streetcleaner))
				{
					int num = RogueDifficultyManager.RoomRNG.Next(0, 5);
					Plugin.Logger.LogInfo((object)$"Weapon choice: {num}");
					switch (num)
					{
					case 0:
						generated = new AWeapon(Plugin.Weapon.Arm, Plugin.Variant.Red);
						break;
					case 1:
						generated = new AWeapon(Plugin.Weapon.Nailgun, Plugin.Variant.Green);
						break;
					case 2:
						generated = new AWeapon(Plugin.Weapon.Shotgun, Plugin.Variant.Blue, (float)RogueDifficultyManager.ItemRNG.NextDouble() <= 0.5f);
						break;
					case 3:
						generated = new AWeapon(Plugin.Weapon.RocketLauncher, Plugin.Variant.Red);
						break;
					default:
						generated = new AWeapon(Plugin.Weapon.Railcannon, Plugin.Variant.Red);
						break;
					}
				}
				else
				{
					Plugin.Weapon wp = (Plugin.Weapon)RogueDifficultyManager.RoomRNG.Next(0, Enum.GetValues(typeof(Plugin.Weapon)).Length);
					Plugin.Variant variant = (Plugin.Variant)RogueDifficultyManager.RoomRNG.Next(0, Enum.GetValues(typeof(Plugin.Variant)).Length);
					bool isAlternate = false;
					if (CanBeAlternate(wp))
					{
						isAlternate = (float)RogueDifficultyManager.ItemRNG.NextDouble() <= 0.5f;
					}
					generated = new AWeapon(wp, variant, isAlternate);
				}
				if (!Plugin.weapons.Any((AWeapon w) => w.weapon == generated.weapon && w.variant == generated.variant && w.Alternate == generated.Alternate))
				{
					return generated;
				}
			}
			Plugin.Logger.LogWarning((object)"All weapon variants owned, returning random duplicate.");
			return new AWeapon(Plugin.Weapon.Revolver, Plugin.Variant.Blue);
		}

		public static bool CanBeAlternate(Plugin.Weapon wp)
		{
			if ((uint)wp <= 2u)
			{
				return true;
			}
			return false;
		}

		public AWeapon(Plugin.Weapon weapon, Plugin.Variant variant, bool isAlternate = false)
		{
			this.weapon = weapon;
			this.variant = variant;
			Alternate = isAlternate;
		}

		public override string ToString()
		{
			return Plugin.getWeaponString(weapon, variant);
		}
	}
	[HarmonyPatch]
	public class WeaponPatches
	{
		[HarmonyPatch(typeof(PrefsManager), "GetInt")]
		[HarmonyPostfix]
		public static void ModifyGuns(ref int __result, string key, int fallback = 0)
		{
			string key2 = key;
			if (!Plugin.isInRogueMode() || !key2.StartsWith("weapon."))
			{
				return;
			}
			if (Plugin.weapons.Any((AWeapon x) => key2.StartsWith(x.ToString())))
			{
				int num = ((!Plugin.weapons.First((AWeapon x) => key2.StartsWith(x.ToString())).Alternate) ? 1 : 2);
				__result = num;
			}
			else
			{
				__result = 0;
			}
		}
	}
	[HarmonyPatch(typeof(StockMapInfo), "Awake")]
	internal static class StockMapInfoPatch
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.isInRogueScene())
			{
				return;
			}
			StatsManager val = Object.FindObjectOfType<StatsManager>();
			if ((Object)(object)val != (Object)null)
			{
				val.levelNumber = -1;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			string currentPath = ((Scene)(ref activeScene)).path;
			foreach (ExecuteOnSceneLoadRogue item in from exe in Resources.FindObjectsOfTypeAll<ExecuteOnSceneLoadRogue>().Where(delegate(ExecuteOnSceneLoadRogue o)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					Scene scene = ((Component)o).gameObject.scene;
					return ((Scene)(ref scene)).path == currentPath;
				})
				orderby exe.relativeExecutionOrder
				select exe)
			{
				try
				{
					item.Execute();
				}
				catch (Exception arg)
				{
					Plugin.Logger.LogError((object)$"Error while executing OnSceneLoad script for {((Object)((Component)item).gameObject).name}: {arg}");
				}
			}
		}
	}
	[HarmonyPatch]
	public class PlayerPatches
	{
		[HarmonyPatch(typeof(Revolver), "Update")]
		public static class Revolver_Update_Patch
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private IEnumerator<CodeInstruction> <>s__1;

				private CodeInstruction <instr>5__2;

				private float <val>5__3;

				CodeInstruction IEnumerator<CodeInstruction>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <Transpiler>d__0(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || (uint)(num - 1) <= 2u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<>s__1 = null;
					<instr>5__2 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_0110: Unknown result type (might be due to invalid IL or missing references)
					//IL_011a: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>s__1 = instructions.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Revolver_Update_Patch), "ModifyRate", (Type[])null, (Type[])null));
							<>1__state = 2;
							return true;
						case 2:
							<>1__state = -3;
							break;
						case 3:
							<>1__state = -3;
							<instr>5__2 = null;
							break;
						}
						if (<>s__1.MoveNext())
						{
							<instr>5__2 = <>s__1.Current;
							if (<instr>5__2.opcode == OpCodes.Ldc_R4)
							{
								<val>5__3 = (float)<instr>5__2.operand;
								if (<val>5__3 == 200f || <val>5__3 == 40f || <val>5__3 == 480f)
								{
									<>2__current = <instr>5__2;
									<>1__state = 1;
									return true;
								}
							}
							<>2__current = <instr>5__2;
							<>1__state = 3;
							return true;
						}
						<>m__Finally1();
						<>s__1 = null;
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				private void <>m__Finally1()
				{
					<>1__state = -1;
					if (<>s__1 != null)
					{
						<>s__1.Dispose();
					}
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}

				[DebuggerHidden]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__0 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__0(0);
					}
					<Transpiler>d__.instructions = <>3__instructions;
					return <Transpiler>d__;
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			[IteratorStateMachine(typeof(<Transpiler>d__0))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__0(-2)
				{
					<>3__instructions = instructions
				};
			}

			public static float ModifyRate(float amount)
			{
				return Plugin.cooldownReduction.CalculateChanges(amount);
			}
		}

		[HarmonyPatch(typeof(Revolver), "Shoot")]
		public static class Revolver_Shoot_V2_Patch
		{
			[CompilerGenerated]
			private sealed class <ExtraShots>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public Revolver __instance;

				private int <i>5__1;

				object IEnumerator<object>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <ExtraShots>d__2(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_0061: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__1 = 0;
						break;
					case 1:
						<>1__state = -1;
						if ((Object)(object)__instance == (Object)null || !((Component)__instance).gameObject.activeInHierarchy)
						{
							return false;
						}
						if (!__instance.inman.InputSource.Fire1.IsPressed)
						{
							return false;
						}
						_isExtraShot = true;
						__instance.Shoot(1);
						_isExtraShot = false;
						<i>5__1++;
						break;
					}
					if (<i>5__1 < 2)
					{
						<>2__current = (object)new WaitForSeconds((__instance.altVersion ? 0.5f : 0.2f) / Plugin.AttackSpeed.CalculateChanges(1f));
						<>1__state = 1;
						return true;
					}
					return false;
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}
			}

			private static bool _isExtraShot;

			[HarmonyPostfix]
			public static void TripleShot(Revolver __instance, int shotType)
			{
				if (!_isExtraShot && shotType == 1)
				{
					BaseCharacter selectedChar = Plugin.SelectedChar;
					if (selectedChar != null && selectedChar.HasPassive(Passive.TripleShot))
					{
						((MonoBehaviour)__instance).StartCoroutine(ExtraShots(__instance));
					}
				}
			}

			[IteratorStateMachine(typeof(<ExtraShots>d__2))]
			private static IEnumerator ExtraShots(Revolver __instance)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <ExtraShots>d__2(0)
				{
					__instance = __instance
				};
			}
		}

		[HarmonyPatch(typeof(Nailgun), "Update")]
		public static class Nailgun_Update_Patch
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private MethodInfo <moveTowards>5__1;

				private MethodInfo <modify>5__2;

				private IEnumerator<CodeInstruction> <>s__3;

				private CodeInstruction <instr>5__4;

				CodeInstruction IEnumerator<CodeInstruction>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <Transpiler>d__0(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || (uint)(num - 1) <= 2u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<moveTowards>5__1 = null;
					<modify>5__2 = null;
					<>s__3 = null;
					<instr>5__4 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f8: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<moveTowards>5__1 = AccessTools.Method(typeof(Mathf), "MoveTowards", (Type[])null, (Type[])null);
							<modify>5__2 = AccessTools.Method(typeof(Nailgun_Update_Patch), "ModifyDelta", (Type[])null, (Type[])null);
							<>s__3 = instructions.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							<>2__current = <instr>5__4;
							<>1__state = 2;
							return true;
						case 2:
							<>1__state = -3;
							goto IL_014e;
						case 3:
							{
								<>1__state = -3;
								goto IL_014e;
							}
							IL_014e:
							<instr>5__4 = null;
							break;
						}
						if (<>s__3.MoveNext())
						{
							<instr>5__4 = <>s__3.Current;
							if (<instr>5__4.opcode == OpCodes.Call && <instr>5__4.operand as MethodInfo == <moveTowards>5__1)
							{
								<>2__current = new CodeInstruction(OpCodes.Call, (object)<modify>5__2);
								<>1__state = 1;
								return true;
							}
							<>2__current = <instr>5__4;
							<>1__state = 3;
							return true;
						}
						<>m__Finally1();
						<>s__3 = null;
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				private void <>m__Finally1()
				{
					<>1__state = -1;
					if (<>s__3 != null)
					{
						<>s__3.Dispose();
					}
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}

				[DebuggerHidden]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__0 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__0(0);
					}
					<Transpiler>d__.instructions = <>3__instructions;
					return <Transpiler>d__;
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			[IteratorStateMachine(typeof(<Transpiler>d__0))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__0(-2)
				{
					<>3__instructions = instructions
				};
			}

			public static float ModifyDelta(float maxDelta)
			{
				return Plugin.cooldownReduction.CalculateChanges(maxDelta);
			}
		}

		[HarmonyPatch(typeof(RocketLauncher), "Update")]
		public static class RocketLauncher_Update_Patch
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private MethodInfo <moveTowards>5__1;

				private MethodInfo <modify>5__2;

				private IEnumerator<CodeInstruction> <>s__3;

				private CodeInstruction <instr>5__4;

				CodeInstruction IEnumerator<CodeInstruction>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <Transpiler>d__0(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || (uint)(num - 1) <= 2u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<moveTowards>5__1 = null;
					<modify>5__2 = null;
					<>s__3 = null;
					<instr>5__4 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f8: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<moveTowards>5__1 = AccessTools.Method(typeof(Mathf), "MoveTowards", (Type[])null, (Type[])null);
							<modify>5__2 = AccessTools.Method(typeof(RocketLauncher_Update_Patch), "ModifyDelta", (Type[])null, (Type[])null);
							<>s__3 = instructions.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							<>2__current = <instr>5__4;
							<>1__state = 2;
							return true;
						case 2:
							<>1__state = -3;
							goto IL_014e;
						case 3:
							{
								<>1__state = -3;
								goto IL_014e;
							}
							IL_014e:
							<instr>5__4 = null;
							break;
						}
						if (<>s__3.MoveNext())
						{
							<instr>5__4 = <>s__3.Current;
							if (<instr>5__4.opcode == OpCodes.Call && <instr>5__4.operand as MethodInfo == <moveTowards>5__1)
							{
								<>2__current = new CodeInstruction(OpCodes.Call, (object)<modify>5__2);
								<>1__state = 1;
								return true;
							}
							<>2__current = <instr>5__4;
							<>1__state = 3;
							return true;
						}
						<>m__Finally1();
						<>s__3 = null;
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				private void <>m__Finally1()
				{
					<>1__state = -1;
					if (<>s__3 != null)
					{
						<>s__3.Dispose();
					}
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}

				[DebuggerHidden]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__0 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__0(0);
					}
					<Transpiler>d__.instructions = <>3__instructions;
					return <Transpiler>d__;
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			[IteratorStateMachine(typeof(<Transpiler>d__0))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__0(-2)
				{
					<>3__instructions = instructions
				};
			}

			public static float ModifyDelta(float maxDelta)
			{
				return Plugin.AttackSpeed.CalculateChanges(maxDelta);
			}
		}

		[HarmonyPatch(typeof(HealthBar), "Update")]
		[HarmonyPrefix]
		public static void DisplayCorrectMaxHP(HealthBar __instance)
		{
			if (__instance.hpSliders.Length != 0)
			{
				Slider[] hpSliders = __instance.hpSliders;
				foreach (Slider val in hpSliders)
				{
					if (((Object)((Component)val).gameObject).name.StartsWith("Supercharge"))
					{
						if (val.maxValue != (float)(Plugin.MaxHealth * 2))
						{
							Plugin.Logger.LogInfo((object)$"Applying thing to {((Object)((Component)val).gameObject).name} that has max of {val.maxValue}");
							val.maxValue = Plugin.MaxHealth * 2;
							val.minValue = Plugin.MaxHealth;
						}
					}
					else if (val.maxValue != (float)Plugin.MaxHealth)
					{
						Plugin.Logger.LogInfo((object)$"Applying thing to {((Object)((Component)val).gameObject).name} that has max of {val.maxValue}");
						val.maxValue = Plugin.MaxHealth;
					}
				}
			}
			if (__instance.afterImageSliders == null)
			{
				return;
			}
			Slider[] afterImageSliders = __instance.afterImageSliders;
			foreach (Slider val2 in afterImageSliders)
			{
				if (val2.maxValue != (float)Plugin.MaxHealth)
				{
					val2.maxValue = Plugin.MaxHealth;
				}
			}
		}

		[HarmonyPatch(typeof(StatsManager), "Update")]
		[HarmonyPrefix]
		public static bool DontRestartLevelRhing(StatsManager __instance)
		{
			if (!Plugin.isInRogueScene())
			{
				return true;
			}
			if (__instance.timer)
			{
				__instance.seconds += Time.deltaTime * GameStateManager.Instance.TimerModifier;
			}
			if (__instance.stylePoints < 0)
			{
				__instance.stylePoints = 0;
			}
			if (!__instance.endlessMode)
			{
				DiscordController.UpdateStyle(__instance.stylePoints);
			}
			return false;
		}

		[HarmonyPatch(typeof(NewMovement), "GetHurt")]
		[HarmonyPostfix]
		public static void Damage(NewMovement __instance)
		{
			if (__instance.dead && Plugin.isInRogueScene())
			{
				((Component)__instance.deathSequence).gameObject.SetActive(false);
				RogueFinalRank.Instance.GameOver();
			}
		}

		[HarmonyPatch(typeof(GasolineStain), "AttachTo")]
		[HarmonyPostfix]
		public static void Stret(GasolineStain __instance)
		{
			//IL_0023: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.SelectedChar.HasPassive(Passive.GasolineFire))
			{
				StainVoxelManager instance = MonoSingleton<StainVoxelManager>.Instance;
				Vector3 forward = ((Component)__instance).transform.forward;
				Vector3 val = ((Component)__instance).transform.position + forward * -0.5f;
				StainVoxel val2 = instance.CreateOrGetVoxel(val, false);
				VoxelProxy val3 = val2.CreateOrGetProxyFor(__instance);
				val3.StartBurningOrRefuel();
			}
		}

		[HarmonyPatch(typeof(FireZone), "OnTriggerStay")]
		[HarmonyPrefix]
		public static bool doNotDamage(FireZone __instance, Collider other)
		{
			if (!Plugin.SelectedChar.HasPassive(Passive.NoFireDamage))
			{
				return true;
			}
			if (((Component)other).CompareTag("Player"))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(Bloodsplatter), "Collide")]
		[HarmonyPrefix]
		public static bool DontHealIfV2(Bloodsplatter __instance, Collider other)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.isInRogueScene())
			{
				return true;
			}
			if (__instance.ready)
			{
				if ((Object)(object)__instance.bsm == (Object)null)
				{
					return false;
				}
				BloodFiller val = default(BloodFiller);
				if (__instance.bsm.hasBloodFillers && ((__instance.bsm.bloodFillers.Contains(((Component)other).gameObject) && ((Component)other).gameObject.TryGetComponent<BloodFiller>(ref val)) || (Object.op_Implicit((Object)(object)other.attachedRigidbody) && __instance.bsm.bloodFillers.Contains(((Component)other.attachedRigidbody).gameObject) && ((Component)other.attachedRigidbody).TryGetComponent<BloodFiller>(ref val))))
				{
					val.FillBloodSlider((float)__instance.hpAmount, ((Component)__instance).transform.position, __instance.eidID);
					return false;
				}
				if (!Plugin.SelectedChar.HasPassive(Passive.HealFromBlood))
				{
					return false;
				}
				if (__instance.canCollide && ((Component)other).gameObject.CompareTag("Player"))
				{
					MonoSingleton<NewMovement>.Instance.GetHealth(__instance.hpAmount, false, __instance.fromExplosion, true);
					__instance.DisableCollider();
				}
			}
			return false;
		}

		[HarmonyPatch(typeof(Bloodsplatter), "CreateBloodstain")]
		[HarmonyPrefix]
		public static bool DontHealIfV2Create(Bloodsplatter __instance)
		{
			if (!Plugin.isInRogueScene())
			{
				return true;
			}
			if (!Plugin.SelectedChar.HasPassive(Passive.HealFromBlood))
			{
				__instance.hpOnParticleCollision = false;
			}
			return true;
		}

		[HarmonyPatch(typeof(NewMovement), "Parry")]
		[HarmonyPrefix]
		public static bool DontHealIfV2Parry(NewMovement __instance, EnemyIdentifier eid = null, string customParryText = "")
		{
			Plugin.Logger.LogInfo((object)$"Parrying as {Plugin.SelectedChar.Name} and we are in the rogue mode {Plugin.isInRogueMode()}");
			if (!Plugin.isInRogueMode())
			{
				return true;
			}
			MonoSingleton<TimeController>.Instance.ParryFlash();
			__instance.exploded = false;
			if (Plugin.SelectedChar.HasPassive(Passive.HealFromBlood))
			{
				__instance.GetHealth(999, false, false, true);
			}
			__instance.FullStamina();
			if ((Object)(object)__instance.shud == (Object)null)
			{
				__instance.shud = MonoSingleton<StyleHUD>.Instance;
			}
			if (!Object.op_Implicit((Object)(object)eid) || !eid.blessed)
			{
				__instance.shud.AddPoints(100, (customParryText != "") ? ("<color=green>" + customParryText + "</color>") : "ultrakill.parry", (GameObject)null, (EnemyIdentifier)null, -1, "", "");
			}
			return false;
		}

		[HarmonyPatch(typeof(NewMovement), "GetHealth")]
		[HarmonyPrefix]
		public static bool HealthChange(NewMovement __instance, int health, bool silent, bool fromExplosion = false, bool bloodsplatter = true)
		{
			if (!__instance.dead && (!__instance.exploded || !fromExplosion))
			{
				float num = health;
				float num2 = Plugin.MaxHealth;
				if (__instance.difficulty == 0 || (__instance.difficulty == 1 && __instance.sameCheckpointRestarts > 2))
				{
					num2 = Plugin.MaxHealth * 2;
				}
				if (num < 1f)
				{
					num = 1f;
				}
				if ((float)__instance.hp <= num2)
				{
					if ((float)__instance.hp + num < num2 - (float)Mathf.RoundToInt(__instance.antiHp))
					{
						__instance.hp += Mathf.RoundToInt(num);
					}
					else if ((float)__instance.hp != num2 - (float)Mathf.RoundToInt(__instance.antiHp))
					{
						__instance.hp = Mathf.RoundToInt(num2) - Mathf.RoundToInt(__instance.antiHp);
					}
					__instance.hpFlash.Flash(1f);
					if (!silent && health > 5)
					{
						if ((Object)(object)__instance.greenHpAud == (Object)null)
						{
							__instance.greenHpAud = ((Component)__instance.hpFlash).GetComponent<AudioSource>();
						}
						AudioSourceExtensions.Play(__instance.greenHpAud, true);
					}
				}
				if (!silent && health > 5 && MonoSingleton<PrefsManager>.Instance.GetBoolLocal("bloodEnabled", false))
				{
					Object.Instantiate<GameObject>(__instance.scrnBlood, ((Component)__instance.fullHud).transform);
				}
			}
			return false;
		}

		[HarmonyPatch(typeof(WeaponCharges), "Charge")]
		[HarmonyPrefix]
		public static void ApplyCooldownPatch(ref float amount)
		{
			amount = Plugin.cooldownReduction.CalculateChanges(amount);
		}
	}
	[HarmonyPatch]
	public class EnemyPatches
	{
		[HarmonyPatch(typeof(EnemyIdentifier), "Death", new Type[] { typeof(bool) })]
		[HarmonyPrefix]
		public static void ActivateDeathEffects(EnemyIdentifier __instance)
		{
			if (!Plugin.isInRogueMode() || __instance.dead)
			{
				return;
			}
			TeamComponent component = ((Component)__instance).GetComponent<TeamComponent>();
			if (component.teamId != Team.Enemies)
			{
				return;
			}
			foreach (DeathEffect deathEffect in Plugin.deathEffects)
			{
				if (Plugin.GetItemCount(deathEffect.itemName) > 0)
				{
					deathEffect.effect(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Enemy), "GetHurt")]
		[HarmonyPrefix]
		public static void ActivateHitEffects(ref float multiplier, Enemy __instance)
		{
			if (!Plugin.isInRogueMode() || __instance.eid.dead)
			{
				return;
			}
			Plugin.Logger.LogInfo((object)$"Damage taken: {multiplier}");
			Plugin.Weapon key = Plugin.HitterToWeapon(__instance.eid.hitter);
			if (Plugin.damageMultipliers.ContainsKey(key))
			{
				multiplier = Plugin.damageMultipliers[key].CalculateChanges(multiplier);
			}
			Plugin.Logger.LogInfo((object)$"Hitter Mult added: {multiplier}");
			multiplier = Plugin.globalDamageMult.CalculateChanges(multiplier);
			Plugin.Logger.LogInfo((object)$"Global Mult added: {multiplier}");
			foreach (DamageModifier dmgModifier in Plugin.dmgModifiers)
			{
				float num = dmgModifier.damageModifier(__instance.eid);
				Plugin.Logger.LogInfo((object)$"Mult added: {num}");
				multiplier *= num;
			}
			foreach (HitEffect hitEffect in Plugin.hitEffects)
			{
				if (Plugin.GetItemCount(hitEffect.itemName) > 0)
				{
					hitEffect.effect(__instance.eid, multiplier);
				}
			}
			Plugin.Logger.LogInfo((object)$"Damage taken after everything: {multiplier}");
		}
	}
	[HarmonyPatch(typeof(EnemyIdentifier), "UpdateTarget")]
	public static class EnemyIdentifier_UpdateTarget_Patch
	{
		private static bool Prefix(EnemyIdentifier __instance)
		{
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.isInRogueMode())
			{
				return true;
			}
			TeamComponent teamComponent = ((Component)__instance).GetComponent<TeamComponent>();
			if ((Object)(object)teamComponent == (Object)null)
			{
				teamComponent = ((Component)__instance).gameObject.AddComponent<TeamComponent>();
				teamComponent.teamId = Team.Enemies;
			}
			if (__instance.target != null && !__instance.target.isValid)
			{
				__instance.target = null;
			}
			if (__instance.dead)
			{
				return false;
			}
			if (teamComponent.teamId == Team.Player)
			{
				__instance.ignorePlayer = true;
			}
			EnemyIdentifier val = null;
			float num = float.MaxValue;
			foreach (EnemyIdentifier currentEnemy in MonoSingleton<EnemyTracker>.Instance.GetCurrentEnemies())
			{
				if ((Object)(object)currentEnemy == (Object)(object)__instance || currentEnemy.dead)
				{
					continue;
				}
				TeamComponent component = ((Component)currentEnemy).GetComponent<TeamComponent>();
				Team team = ((!((Object)(object)component != (Object)null)) ? Team.Enemies : component.teamId);
				if (team != teamComponent.teamId)
				{
					float num2 = Vector3.Distance(((Component)__instance).transform.position, ((Component)currentEnemy).transform.position);
					if (num2 < num)
					{
						num = num2;
						val = currentEnemy;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				__instance.target = new EnemyTarget(((Component)val).transform);
				return false;
			}
			if (teamComponent.teamId == Team.Player)
			{
				__instance.target = null;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EnemyIdentifier), "Start")]
	public static class EnemyIdentifier_Awake_Patch
	{
		private static void Postfix(EnemyIdentifier __instance)
		{
			if (Plugin.isInRogueMode() && (Object)(object)((Component)__instance).GetComponent<TeamComponent>() == (Object)null)
			{
				TeamComponent teamComponent = ((Component)__instance).gameObject.AddComponent<TeamComponent>();
				teamComponent.teamId = Team.Enemies;
			}
		}
	}
	[HarmonyPatch(typeof(EnemyIdentifier), "StartBurning")]
	public static class BurningHeal
	{
		private static void Postfix(EnemyIdentifier __instance)
		{
			if (Plugin.isInRogueMode() && Plugin.SelectedChar.HasPassive(Passive.NoFireDamage))
			{
				MonoSingleton<NewMovement>.Instance.GetHealth(5, false, false, true);
			}
		}
	}
	[HarmonyPatch(typeof(DiscordController), "SendActivity")]
	public class ReplaceActivity
	{
		public static void Prefix(DiscordController __instance)
		{
			if (Plugin.isInRogueScene())
			{
				__instance.cachedActivity.State = "ROGUE MODE";
				__instance.cachedActivity.Details = "Floor: " + RogueDifficultyManager.Instance.floor;
				__instance.cachedActivity.Assets.LargeImage = "level_0-1";
			}
		}
	}
	[HarmonyPatch(typeof(Console), "Awake")]
	public class AddCommands
	{
		public class Ultrarogue : CommandRoot, IConsoleLogger
		{
			public override string Name => "ULTRAROGUE";

			public override string Description => "Commands for ultrarogue";

			public Logger Log => new Logger("Buffs");

			public Ultrarogue(Console con)
				: base(con)
			{
			}

			public override Branch BuildTree(Console con)
			{
				string text = "ultrarogue";
				Node[] array = (Node[])(object)new Node[3];
				List<Node> list = new List<Node>();
				list.Add((Node)(object)CommandRoot.Leaf("addall", (Action)delegate
				{
					foreach (KeyValuePair<string, BaseItem> item2 in Plugin.nameToItem)
					{
						Plugin.GiveItem(item2.Value);
					}
					Log.Info($"Gave all the items, item count: {Plugin.nameToItem.Count}", (IEnumerable<Tag>)null, (string)null, (object)null);
				}, true));
				foreach (KeyValuePair<string, BaseItem> item in Plugin.nameToItem)
				{
					list.Add((Node)(object)CommandRoot.Leaf("add_" + item.Value.ItemName.Replace(" ", "_"), (Action)delegate
					{
						Plugin.GiveItem(item.Value);
						Log.Info("Gave item " + item.Value.ItemName, (IEnumerable<Tag>)null, (string)null, (object)null);
					}, true));
				}
				Branch val = CommandRoot.Branch("items", list.ToArray());
				array[0] = (Node)(object)val;
				array[1] = (Node)(object)CommandRoot.Branch("floor", (Node[])(object)new Node[2]
				{
					(Node)CommandRoot.Leaf("revealfloor", (Action)delegate
					{
						if ((Object)(object)MinimapUI.Instance == (Object)null)
						{
							Log.Error("No minimap found!", (IEnumerable<Tag>)null, (string)null, (object)null);
						}
						else
						{
							MinimapUI.Instance.RevealAll();
						}
					}, true),
					(Node)CommandRoot.Leaf("nextstage", (Action)delegate
					{
						//IL_001a: Unknown result type (might be due to invalid IL or missing references)
						((Component)MonoSingleton<NewMovement>.Instance).transform.position = GameObject.Find("PortalPos").transform.position;
						RoomGenerator.Instance.RegenerateRooms();
					}, true)
				});
				return CommandRoot.Branch(text, array);
			}
		}

		public static void Postfix(Console __instance)
		{
			__instance.RegisterCommand((ICommand)(object)new Ultrarogue(__instance));
		}
	}
	public class RogueSaveData
	{
		public List<RogueSaveDataData> datas { get; set; }

		public RogueSaveDataData BestRun { get; set; }
	}
	public class RogueSaveDataData
	{
		public int Floor { get; set; }

		public int Kills { get; set; }

		public int ItemsGotten { get; set; }

		public float Time { get; set; }
	}
	public class DeathEffect
	{
		public string itemName;

		public Action<EnemyIdentifier> effect;

		public DeathEffect(string itemName, Action<EnemyIdentifier> effect)
		{
			this.itemName = itemName;
			this.effect = effect;
			Plugin.deathEffects.Add(this);
		}
	}
	public class DamageModifier
	{
		public string itemName;

		public Func<EnemyIdentifier, float> damageModifier;

		public DamageModifier(string itemName, Func<EnemyIdentifier, float> damageModifier)
		{
			this.itemName = itemName;
			this.damageModifier = damageModifier;
			Plugin.dmgModifiers.Add(this);
		}
	}
	public class HitEffect
	{
		public string itemName;

		public Action<EnemyIdentifier, float> effect;

		public HitEffect(string itemName, Action<EnemyIdentifier, float> effect)
		{
			this.itemName = itemName;
			this.effect = effect;
			Plugin.hitEffects.Add(this);
		}
	}
	public class DropTable
	{
		public Dictionary<Rarity, float> weights = new Dictionary<Rarity, float>();

		public DropTable(Dictionary<Rarity, float> weights)
		{
			this.weights = weights;
		}
	}
	public class PlayerChange
	{
		public Change moveSpeed;

		public Change jumpHeight;

		public Change maxHealth;

		public Change attackSpeed;

		public Change cooldownRed;

		public List<DamageChange> damageChanges;

		public Change globalDamageMult;

		public PlayerChange(Change moveSpeed = null, Change jumpHeight = null, Change maxHealth = null, Change attackSpeed = null, Change cooldownReduction = null, List<DamageChange> damageChanges = null, Change globalDamageMult = null)
		{
			if (moveSpeed == null)
			{
				moveSpeed = new Change();
			}
			if (jumpHeight == null)
			{
				jumpHeight = new Change();
			}
			if (damageChanges == null)
			{
				damageChanges = new List<DamageChange>();
			}
			if (globalDamageMult == null)
			{
				globalDamageMult = new Change();
			}
			if (maxHealth == null)
			{
				maxHealth = new Change();
			}
			if (attackSpeed == null)
			{
				attackSpeed = new Change();
			}
			if (cooldownReduction == null)
			{
				cooldownReduction = new Change();
			}
			this.moveSpeed = moveSpeed;
			this.jumpHeight = jumpHeight;
			this.damageChanges = damageChanges;
			this.globalDamageMult = globalDamageMult;
			this.maxHealth = maxHealth;
			this.attackSpeed = attackSpeed;
			cooldownRed = cooldownReduction;
			Plugin.playerChanges.Add(this);
		}
	}
	public class Change
	{
		public float addition;

		public float percentage;

		public float multiplier;

		public Change(float addition = 0f, float percentage = 0f, float multiplier = 1f)
		{
			this.addition = addition;
			this.percentage = percentage;
			this.multiplier = multiplier;
		}

		public void ApplyChangeToChange(Change change)
		{
			addition += change.addition;
			percentage += change.percentage;
			multiplier *= change.multiplier;
		}

		public float CalculateChanges(float normalVal)
		{
			float num = percentage + 1f;
			float num2 = normalVal;
			num2 *= num;
			num2 *= multiplier;
			return num2 + addition;
		}
	}
	public class DamageChange
	{
		public Plugin.Weapon WeaponType;

		public Change damageChange;

		public DamageChange(Plugin.Weapon weaponType, Change damageChange)
		{
			WeaponType = weaponType;
			this.damageChange = damageChange;
		}
	}
	[HarmonyPatch]
	public static class SceneLoader
	{
		[CompilerGenerated]
		private sealed class <LoadLevelAsync>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool noSplash;

			private AsyncOperationHandle<SceneInstance> <op>5__1;

			private string <randomMessage>5__2;

			private string[] <userMessages>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadLevelAsync>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				<op>5__1 = default(AsyncOperationHandle<SceneInstance>);
				<randomMessage>5__2 = null;
				<userMessages>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0152: 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_016f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: 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_01fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Expected O, but got Unknown
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (LoadingScene)
					{
						return false;
					}
					LoadingScene = true;
					logger.LogInfo((object)"Loading Empty Scene...");
					SceneHelper.PendingScene = "Ultrarogue";
					if (!noSplash)
					{
						MonoSingleton<SceneHelper>.Instance.loadingBlocker.SetActive(true);
						<randomMessage>5__2 = messages[Random.Range(0, messages.Length)];
						if (SteamClient.IsLoggedOn && customMessagesForYoutubers.ContainsKey(SteamClient.SteamId) && Random.value <= 0.25f)
						{
							<userMessages>5__3 = customMessagesForYoutubers[SteamClient.SteamId];
							<randomMessage>5__2 = <userMessages>5__3[Random.Range(0, <userMessages>5__3.Length)];
							<userMessages>5__3 = null;
						}
						SceneHelper.SetLoadingSubtext(<randomMessage>5__2);
						<randomMessage>5__2 = null;
					}
					if (!Loaded)
					{
						Load();
					}
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					AssetsManager.weaponMat = Addressables.LoadAssetAsync<Material>((object)"Assets/Modding/RogueMode/WeaponPickup.mat").WaitForCompletion();
					<op>5__1 = Addressables.LoadSceneAsync((object)"Assets/Modding/RogueMode/EpicLevel.unity", (LoadSceneMode)0, true, 100);
					<>2__current = <op>5__1;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (SceneHelper.CurrentScene != "Ultrarogue")
					{
						SceneHelper.LastScene = SceneHelper.CurrentScene;
					}
					SceneHelper.CurrentScene = "Ultrarogue";
					logger.LogInfo((object)"Scene loaded!");
					SceneHelper.PendingScene = null;
					SceneHelper.SetLoadingSubtext("");
					MonoSingleton<SceneHelper>.Instance.loadingBlocker.SetActive(false);
					new GameObject("NavMesh").AddComponent<NavMeshSurface>();
					((MonoBehaviour)Plugin.Instance).StartCoroutine(PlayPixelAnimation());
					LoadingScene = false;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <PlayPixelAnimation>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private float <target>5__1;

			private float <actualTarget>5__2;

			private float <t>5__3;

			private NewMovement <nm>5__4;

			private GunControl <gc>5__5;

			private float <pixelizationValue>5__6;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PlayPixelAnimation>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<nm>5__4 = null;
				<gc>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c4: 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_006a: Expected O, but got Unknown
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				//IL_0285: Unknown result type (might be due to invalid IL or missing references)
				//IL_028a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c4: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)MonoSingleton<PostProcessV2_Handler>.Instance != (Object)null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)MonoSingleton<NewMovement>.Instance != (Object)null));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					Plugin.RogueMode = true;
					((Component)MonoSingleton<NewMovement>.Instance).transform.position = Vector3.zero;
					<target>5__1 = MonoSingleton<PostProcessV2_Handler>.Instance.downscaleResolution;
					<actualTarget>5__2 = <target>5__1;
					if (<target>5__1 == 0f)
					{
						<target>5__1 = 720f;
					}
					<t>5__3 = 0f;
					goto IL_017e;
				case 3:
					<>1__state = -1;
					goto IL_017e;
				case 4:
					{
						<>1__state = -1;
						Disable();
						return false;
					}
					IL_017e:
					if (<t>5__3 < 1f)
					{
						<t>5__3 += Time.deltaTime;
						<pixelizationValue>5__6 = Mathf.Lerp(1f, <target>5__1, <t>5__3);
						Shader.SetGlobalFloat("_ResY", <pixelizationValue>5__6);
						MonoSingleton<PostProcessV2_Handler>.Instance.downscaleResolution = <pixelizationValue>5__6;
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					Shader.SetGlobalFloat("_ResY", <actualTarget>5__2);
					MonoSingleton<PostProcessV2_Handler>.Instance.downscaleResolution = <actualTarget>5__2;
					<nm>5__4 = MonoSingleton<NewMovement>.Instance;
					<gc>5__5 = MonoSingleton<GunControl>.Instance;
					GameStateManager.Instance.PopState("pit-falling");
					if (!<nm>5__4.activated)
					{
						<nm>5__4.activated = true;
						<nm>5__4.cc.activated = true;
						<nm>5__4.cc.CameraShake(1f);
						((Behaviour)<nm>5__4.cc).enabled = true;
					}
					<gc>5__5.YesWeapon();
					MonoSingleton<PlayerActivatorRelay>.Instance.ResetIndex();
					MonoSingleton<PlayerActivatorRelay>.Instance.Activate();
					if (<nm>5__4.levelOver)
					{
						<nm>5__4.levelOver = false;
						MonoSingleton<StatsManager>.Instance.UnhideShit();
					}
					PlayerActivator.lastActivatedPosition = ((Component)MonoSingleton<NewMovement>.Instance).transform.position;
					MonoSingleton<FistControl>.Instance.YesFist();
					MonoSingleton<StatsManager>.Instance.StartTimer();
					MonoSingleton<NewMovement>.Instance.hp = Plugin.MaxHealth;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 4;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static ManualLogSource logger = Logger.CreateLogSource("Ultrarogue:: SceneLoader");

		public const string SceneName = "Ultrarogue";

		public static bool Loaded = false;

		private static string[] messages = new string[7] { "The higher the you set the difficulty, the more rooms, and enemies spawn", "Although items can greatly help survivability, getting your arsenal is a bigger priority", "Difficulty gets increased over time, causing more enemies to spawn, and sometimes make them radiant", "Each room has a chance to give nothing, gold, or keys!", "Some items are better for specific classes", "Pressing tab shows a minimap, your stats, and your items.", "Sometimes special rooms are locked and require a key to be opened" };

		public static Dictionary<SteamId, string[]> customMessagesForYoutubers = new Dictionary<SteamId, string[]>
		{
			{
				SteamId.op_Implicit(76561199195414858uL),
				new string[3] { "Hi linguini, (and maybe lasagna)", "Where are my goddamnt cookies?", "you probably dont need items." }
			},
			{
				SteamId.op_Implicit(76561199354650051uL),
				new string[4] { "Bronf", "Cronf", "Shlonf", "Splonf" }
			},
			{
				SteamId.op_Implicit(76561199124864632uL),
				new string[7] { "tongler", "Toolbar", "tungsten", "tond tond tond yzdur", "toenail", "tondler", "johndar" }
			},
			{
				SteamId.op_Implicit(76561198377209797uL),
				new string[4] { "slop", "more slop", "ultra slop", "when risk of slop 2?" }
			},
			{
				SteamId.op_Implicit(76561198300312593uL),
				new string[7] { "oh, hi me :D", "your mod fucking sucks", "WHY DID I ADD THIS", "i am writing insults to myself", "unless someone reads the code (hi person who reads the code)", "no one will see this", "hello :D" }
			}
		};

		private static bool LoadingScene = false;

		public static void Load()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Addressables.LoadAssetAsync<GameObject>((object)"FirstRoom").WaitForCompletion();
			BundleLoader.Load();
		}

		[IteratorStateMachine(typeof(<LoadLevelAsync>d__7))]
		public static IEnumerator LoadLevelAsync(bool noSplash)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadLevelAsync>d__7(0)
			{
				noSplash = noSplash
			};
		}

		[IteratorStateMachine(typeof(<PlayPixelAnimation>d__8))]
		private static IEnumerator PlayPixelAnimation()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayPixelAnimation>d__8(0);
		}

		private static void Disable()
		{
			GameObject gameObject = ((Component)Object.FindObjectOfType<OptionsMenuToManager>(true)).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				Plugin.Logger.LogInfo((object)"Canvas not found");
				return;
			}
			Plugin.Logger.LogInfo((object)"Waiting for LevelStats...");
			Plugin.Logger.LogInfo((object)"LevelStats found!");
			Transform transform = ((Component)gameObject.GetComponentInChildren<LevelStats>(true)).transform;
			Plugin.Logger.LogInfo((object)("Found stats object: " + ((Object)transform).name));
			if ((Object)(object)transform == (Object)null)
			{
				Plugin.Logger.LogInfo((object)"Level Stats (1) not found");
				return;
			}
			LevelStats[] componentsInChildren = gameObject.GetComponentsInChildren<LevelStats>(true);
			foreach (LevelStats val in componentsInChildren)
			{
				Transform[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<Transform>(true);
				foreach (Transform val2 in componentsInChildren2)
				{
					if ((Object)(object)val2 != (Object)(object)val)
					{
						Plugin.Logger.LogInfo((object)("Disabling: " + ((Object)val2).name));
						((Component)val2).gameObject.SetActive(false);
					}
				}
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SceneHelper), "LoadSceneCoroutine")]
		public static bool RedirectSceneHelperSceneLoader(ref IEnumerator __result, string sceneName, bool noSplash)
		{
			if (sceneName == "Ultrarogue")
			{
				Plugin.LoadLevel("");
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LevelStatsEnabler), "Update")]
		public static bool STOPPPSPAWNINGGGGG(LevelStatsEnabler __instance)
		{
			if ((Object)(object)Object.FindObjectOfType<RogueDifficultyManager>() != (Object)null)
			{
				return false;
			}
			return true;
		}
	}
	internal static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.bananastudio.ultrarogue";

		public const string PLUGIN_NAME = "My first plugin";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace Ultrarogue.SceneStuff
{
	public class KeyPickup : MonoBehaviour
	{
		private bool pickedUp = false;

		private void Update()
		{
			//IL_000b: 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)
			if (Vector3.Distance(((Component)MonoSingleton<NewMovement>.Instance).transform.position, ((Component)this).transform.position) <= 2f && !pickedUp)
			{
				pickedUp = true;
				RogueDifficultyManager.Instance.Keys++;
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public static void CreatePickup(Vector3 position)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)5);
			val.GetComponent<Collider>().enabled = false;
			val.AddComponent<KeyPickup>();
			Material material = new Material(MonoSingleton<DefaultReferenceManager>.Instance.masterShader);
			((Renderer)val.GetComponent<MeshRenderer>()).material = material;
			val.transform.position = position + Vector3.up * 3f;
			Transform transform = val.transform;
			transform.localScale *= 3f;
		}
	}
	public class Lockable : MonoBehaviour
	{
		public bool locked = true;

		private void Awake()
		{
			Door val = default(Door);
			if (((Component)this).gameObject.TryGetComponent<Door>(ref val))
			{
				val.Lock();
			}
			Transform val2 = ((Component)this).transform.Find("LockObject");
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)this).transform.parent.Find("LockObject");
			}
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(true);
			}
		}

		private void Update()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!Room.isFighting && Vector3.Distance(((Component)MonoSingleton<NewMovement>.Instance).transform.position, ((Component)this).transform.position) <= 2f && locked && RogueDifficultyManager.Instance.Keys >= 1)
			{
				locked = false;
				RogueDifficultyManager.Instance.Keys--;
				Door val = default(Door);
				if (((Component)this).gameObject.TryGetComponent<Door>(ref val))
				{
					val.Unlock();
				}
				Transform val2 = ((Component)this).transform.Find("LockObject");
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)this).transform.parent.Find("LockObject");
				}
				if ((Object)(object)val2 != (Object)null)
				{
					((Component)val2).gameObject.SetActive(false);
				}
				Object.Instantiate<GameObject>(AssetsManager.BreakParticle, ((Component)this).transform.position, Quaternion.identity);
			}
		}
	}
	public class WeaponPickupRogue : MonoBehaviour
	{
		public AWeapon weapon;

		private bool pickedUp = false;

		private Func<bool> canPickup;

		private void Update()
		{
			//IL_003c: 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)
			((Component)this).transform.LookAt(((Component)Camera.main).transform);
			((Component)this).transform.Rotate(0f, 180f, 0f);
			if (Vector3.Distance(((Component)MonoSingleton<NewMovement>.Instance).transform.position, ((Component)this).transform.position) <= 2f && !pickedUp && (canPickup == null || canPickup()))
			{
				pickedUp = true;
				Plugin.AddWeapon(weapon);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public static void CreatePickup(Transform position)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)5);
			val.GetComponent<Collider>().enabled = false;
			AWeapon aWeapon = AWeapon.GenerateWeapon();
			Material val2 = new Material(AssetsManager.weaponMat);
			val2.SetInt("_CullMode", 0);
			val2.EnableKeyword("BILLBOARD");
			Sprite val3 = AssetsManager.prefToDescriptor(aWeapon.ToString(), aWeapon.Alternate);
			Rect textureRect = val3.textureRect;
			Texture2D texture = val3.texture;
			RenderTexture val4 = new RenderTexture((int)((Rect)(ref textureRect)).width, (int)((Rect)(ref textureRect)).height, 0);
			Graphics.Blit((Texture)(object)texture, val4, new Vector2(((Rect)(ref textureRect)).width / (float)((Texture)texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)texture).height), new Vector2(((Rect)(ref textureRect)).x / (float)((Texture)texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)texture).height));
			RenderTexture.active = val4;
			Texture2D val5 = new Texture2D((int)((Rect)(ref textureRect)).width, (int)((Rect)(ref textureRect)).height);
			val5.ReadPixels(new Rect(0f, 0f, ((Rect)(ref textureRect)).width, ((Rect)(ref textureRect)).height), 0, 0);
			val5.Apply();
			RenderTexture.active = null;
			val4.Release();
			Color[] pixels = val5.GetPixels();
			for (int i = 0; i < pixels.Length; i++)
			{
				pixels[i] = new Color(1f - pixels[i].r, 1f - pixels[i].g, 1f - pixels[i].b, pixels[i].a);
			}
			val5.SetPixels(pixels);
			val5.Apply();
			val2.mainTexture = (Texture)(object)val5;
			((Renderer)val.GetComponent<MeshRenderer>()).material = val2;
			val.AddComponent<WeaponPickupRogue>().weapon = aWeapon;
			val.transform.position = position.position + Vector3.up * 2f;
			val.transform.parent = position;
			Transform transform = val.transform;
			transform.localScale *= 2f;
			val.transform.localScale = new Vector3(val.transform.localScale.x * 2f, val.transform.localScale.y, val.transform.localScale.z);
		}

		public static void CreatePickupConditional(Transform position, Func<bool> pickupCon, float offset = 2f, AWeapon weapon = null)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)5);
			val.GetComponent<Collider>().enabled = false;
			if (weapon == null)
			{
				weapon = AWeapon.GenerateWeapon();
			}
			Material val2 = new Material(AssetsManager.weaponMat);
			val2.SetInt("_CullMode", 0);
			val2.EnableKeyword("BILLBOARD");
			Sprite val3 = AssetsManager.prefToDescriptor(weapon.ToString(), weapon.Alternate);
			Rect textureRect = val3.textureRect;
			Texture2D texture = val3.texture;
			RenderTexture val4 = new RenderTexture((int)((Rect)(ref textureRect)).width, (int)((Rect)(ref textureRect)).height, 0);
			Graphics.Blit((Texture)(object)texture, val4, new Vector2(((Rect)(ref textureRect)).width / (float)((Texture)texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)texture).height), new Vector2(((Rect)(ref textureRect)).x / (float)((Texture)texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)texture).height));
			RenderTexture.active = val4;
			Texture2D val5 = new Texture2D((int)((Rect)(ref textureRect)).width, (int)((Rect)(ref textureRect)).height);
			val5.ReadPixels(new Rect(0f, 0f, ((Rect)(ref textureRect)).width, ((Rect)(ref textureRect)).height), 0, 0);
			val5.Apply();
			RenderTexture.active = null;
			val4.Release();
			Color[] pixels = val5.GetPixels();
			for (int i = 0; i < pixels.Length; i++)
			{
				pixels[i] = new Color(1f - pixels[i].r, 1f - pixels[i].g, 1f - pixels[i].b, pixels[i].a);
			}
			val5.SetPixels(pixels);
			val5.Apply();
			val2.mainTexture = (Texture)(object)val5;
			((Renderer)val.GetComponent<MeshRenderer>()).material = val2;
			WeaponPickupRogue weaponPickupRogue = val.AddComponent<WeaponPickupRogue>();
			weaponPickupRogue.weapon = weapon;
			weaponPickupRogue.canPickup = pickupCon;
			val.transform.position = position.position + Vector3.up * offset;
			val.transform.parent = position;
			Transform transform = val.transform;
			transform.localScale *= 2f;
			val.transform.localScale = new Vector3(val.transform.localScale.x * 2f, val.transform.localScale.y, val.transform.localScale.z);
		}
	}
}
namespace Ultrarogue.Items
{
	public abstract class BaseItem
	{
		public virtual bool CanOnlyHaveOne => false;

		public virtual string ItemName => "";

		public virtual string itemDescription => string.Empty;

		public virtual string ItemIconName => ItemName.Replace(" ", "_");

		public virtual Rarity Rarity => Rarity.Common;

		public virtual List<ItemTag> itemTags => new List<ItemTag>();

		public virtual List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon>();

		public Sprite ItemIcon
		{
			get
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				Texture2D itemTexture = ItemTexture;
				if ((Object)(object)itemTexture == (Object)null)
				{
					return null;
				}
				return Sprite.Create(itemTexture, new Rect(0f, 0f, (float)((Texture)itemTexture).width, (float)((Texture)itemTexture).height), new Vector2(0.5f, 0.5f));
			}
		}

		public Texture2D ItemTexture
		{
			get
			{
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Expected O, but got Unknown
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				string text = "Ultrarogue.ItemIcons." + ItemIconName + ".png";
				using Stream stream = executingAssembly.GetManifestResourceStream(text);
				if (stream == null)
				{
					Debug.LogWarning((object)("[ItemIcon] Resource not found: " + text));
					return null;
				}
				byte[] array = new byte[stream.Length];
				stream.Read(array, 0, array.Length);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				ImageConversion.LoadImage(val, array);
				((Texture)val).filterMode = (FilterMode)0;
				((Object)val).name = ItemIconName;
				return val;
			}
		}

		public virtual void OnGotten(int count, bool firstPickup)
		{
		}

		public virtual void OnStart()
		{
		}

		public virtual void OnUpdate(int count)
		{
		}

		public virtual void OnRemoval()
		{
		}

		public void StartCoroutine(IEnumerator routine)
		{
			((MonoBehaviour)Plugin.Instance).StartCoroutine(routine);
		}

		public override string ToString()
		{
			return "Item name: " + ItemName + ", description: " + itemDescription;
		}
	}
	public enum ItemTag
	{
		Utility,
		Damage,
		Healing
	}
	public class SoldierChip : BaseItem
	{
		private Change atkSpeedChange;

		public override string ItemName => "Soldier Chip";

		public override string itemDescription => "Increase firerate by 15%";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			atkSpeedChange = new Change();
			new PlayerChange(null, null, null, atkSpeedChange);
		}

		public override void OnUpdate(int count)
		{
			atkSpeedChange.percentage = 0.15f * (float)count;
		}

		public override void OnRemoval()
		{
			atkSpeedChange.percentage = 0f;
		}
	}
	[HarmonyPatch]
	public class BiggerShells : BaseItem
	{
		private DamageChange damageChange;

		private static BiggerShells Instance { get; set; }

		public override string ItemName => "Bigger Shells";

		public override string itemDescription => "Shotgun damage +10%, projectiles are 7% larger";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Shotgun };

		public override void OnStart()
		{
			Instance = this;
			damageChange = new DamageChange(Plugin.Weapon.Shotgun, new Change());
			new PlayerChange(null, null, null, null, null, new List<DamageChange> { damageChange });
		}

		public override void OnUpdate(int count)
		{
			damageChange.damageChange.percentage = 0.1f * (float)count;
		}

		public override void OnRemoval()
		{
			damageChange.damageChange.percentage = 0f;
		}

		[HarmonyPatch(typeof(Projectile), "Awake")]
		public static void Prefix(Projectile __instance)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.GetItemCount(Instance) > 0 && __instance.playerBullet)
			{
				Transform transform = ((Component)__instance).transform;
				transform.localScale *= 1f + 0.07f * (float)Plugin.GetItemCount(Instance);
			}
		}
	}
	public class Improvement : BaseItem
	{
		private PlayerChange plrChanges;

		public override string ItemName => "Scrap Parts";

		public override string itemDescription => "+10% to your lowest stat";

		public override void OnStart()
		{
			plrChanges = new PlayerChange();
		}

		public override void OnGotten(int count, bool firstPickup)
		{
			if (!((Object)(object)MonoSingleton<NewMovement>.Instance == (Object)null))
			{
				float walkSpeed = MonoSingleton<NewMovement>.Instance.walkSpeed;
				float normalMoveSpeed = Plugin.Instance.normalMoveSpeed;
				float item = walkSpeed / normalMoveSpeed;
				float item2 = Plugin.AttackSpeed.CalculateChanges(1f);
				float item3 = Plugin.globalDamageMult.CalculateChanges(1f);
				float item4 = Plugin.cooldownReduction.CalculateChanges(1f);
				(string, float)[] source = new(string, float)[4]
				{
					("MS", item),
					("AS", item2),
					("D", item3),
					("C", item4)
				};
				(string, float) tuple = source.OrderBy(((string, float) x) => x.Item2).First();
				if (tuple.Item1 == "MS")
				{
					plrChanges.moveSpeed.percentage += 0.1f;
				}
				else if (tuple.Item1 == "AS")
				{
					plrChanges.attackSpeed.percentage += 0.1f;
				}
				else if (tuple.Item1 == "D")
				{
					plrChanges.globalDamageMult.percentage += 0.1f;
				}
				else if (tuple.Item1 == "C")
				{
					plrChanges.cooldownRed.percentage += 0.1f;
				}
			}
		}

		public override void OnRemoval()
		{
			plrChanges.moveSpeed = new Change();
			plrChanges.attackSpeed = new Change();
			plrChanges.globalDamageMult = new Change();
			plrChanges.cooldownRed = new Change();
		}
	}
	public class Gasoline : BaseItem
	{
		[CompilerGenerated]
		private sealed class <SpawnNapalm>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Transform pos;

			public Gasoline <>4__this;

			private GameObject <obj>5__1;

			private Rigidbody <rb>5__2;

			private Vector3 <randomDir>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SpawnNapalm>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<obj>5__1 = null;
				<rb>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<obj>5__1 = Object.Instantiate<GameObject>(AssetsManager.napalmProj, pos.position + Vector3.up, Quaternion.identity);
					<rb>5__2 = <obj>5__1.GetComponent<Rigidbody>();
					Vector3 val = new Vector3(Random.Range(-1f, 1f), Random.Range(0.5f, 1f), Random.Range(-1f, 1f));
					<randomDir>5__3 = ((Vector3)(ref val)).normalized;
					<rb>5__2.velocity = <randomDir>5__3 * 25f;
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public override string ItemName => "Gasoline";

		public override string itemDescription => "On kill, create 10 (+2 per stack) gasoline projectiles";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			new DeathEffect(ItemName, delegate(EnemyIdentifier eid)
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount > 0)
				{
					for (int i = 0; i < 2 * itemCount + 10; i++)
					{
						StartCoroutine(SpawnNapalm(((Component)eid).transform));
					}
				}
			});
		}

		[IteratorStateMachine(typeof(<SpawnNapalm>d__7))]
		private IEnumerator SpawnNapalm(Transform pos)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnNapalm>d__7(0)
			{
				<>4__this = this,
				pos = pos
			};
		}
	}
	public class SmallKit : BaseItem
	{
		private Change hpChange;

		public override string ItemName => "Small Kit";

		public override string itemDescription => "+10 max hp per stack";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Healing };

		public override void OnStart()
		{
			hpChange = new Change();
			new PlayerChange(null, null, hpChange);
		}

		public override void OnGotten(int count, bool firstPickup)
		{
			if (count != 0)
			{
				MonoSingleton<NewMovement>.Instance.GetHealth(10, true, false, true);
			}
		}

		public override void OnUpdate(int count)
		{
			hpChange.addition = 10 * count;
		}

		public override void OnRemoval()
		{
			hpChange.addition = 0f;
		}
	}
	public class SandWorm : BaseItem
	{
		public override string ItemName => "Sand Worm";

		public override string itemDescription => "Sanded enemies take +35% more damage";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			new DamageModifier(ItemName, delegate(EnemyIdentifier eid)
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount == 0)
				{
					return 1f;
				}
				return (!eid.sandified) ? 1f : (1f + 0.35f * (float)itemCount);
			});
		}
	}
	public class KnuckleDuster : BaseItem
	{
		private DamageChange damageChange;

		public override string ItemName => "Knuckle Duster";

		public override string itemDescription => "Arm damage +15%";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Arm };

		public override void OnStart()
		{
			damageChange = new DamageChange(Plugin.Weapon.Arm, new Change());
			new PlayerChange(null, null, null, null, null, new List<DamageChange> { damageChange });
		}

		public override void OnUpdate(int count)
		{
			damageChange.damageChange.percentage = 0.15f * (float)count;
		}

		public override void OnRemoval()
		{
			damageChange.damageChange.percentage = 0f;
		}
	}
	public class SpeedLoader : BaseItem
	{
		private DamageChange damageChange;

		public override string ItemName => "Heavy Loader";

		public override string itemDescription => "Revolver damage +12%";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Revolver };

		public override void OnStart()
		{
			damageChange = new DamageChange(Plugin.Weapon.Revolver, new Change());
			new PlayerChange(null, null, null, null, null, new List<DamageChange> { damageChange });
		}

		public override void OnUpdate(int count)
		{
			damageChange.damageChange.percentage = 0.12f * (float)count;
		}

		public override void OnRemoval()
		{
			damageChange.damageChange.percentage = 0f;
		}
	}
	public class RunningShoes : BaseItem
	{
		private Change moveChange;

		public override string ItemName => "Running Shoes";

		public override string itemDescription => "Move speed +8%";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Utility };

		public override void OnStart()
		{
			moveChange = new Change();
			new PlayerChange(moveChange);
		}

		public override void OnUpdate(int count)
		{
			moveChange.percentage = 0.08f * (float)count;
		}

		public override void OnRemoval()
		{
			moveChange.percentage = 0f;
		}
	}
	public class APRounds : BaseItem
	{
		private DamageChange damageChange;

		public override string ItemName => "AP Rounds";

		public override string itemDescription => "Railcannon damage +15%";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Railcannon };

		public override void OnStart()
		{
			damageChange = new DamageChange(Plugin.Weapon.Railcannon, new Change());
			new PlayerChange(null, null, null, null, null, new List<DamageChange> { damageChange });
		}

		public override void OnUpdate(int count)
		{
			damageChange.damageChange.percentage = 0.15f * (float)count;
		}

		public override void OnRemoval()
		{
			damageChange.damageChange.percentage = 0f;
		}
	}
	public class LooseNails : BaseItem
	{
		private DamageChange damageChange;

		public override string ItemName => "Loose Nails";

		public override string itemDescription => "Nailgun damage +10%";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Nailgun };

		public override void OnStart()
		{
			damageChange = new DamageChange(Plugin.Weapon.Nailgun, new Change());
			new PlayerChange(null, null, null, null, null, new List<DamageChange> { damageChange });
		}

		public override void OnUpdate(int count)
		{
			damageChange.damageChange.percentage = 0.1f * (float)count;
		}

		public override void OnRemoval()
		{
			damageChange.damageChange.percentage = 0f;
		}
	}
	public class PogoStick : BaseItem
	{
		private Change jumpChange;

		public override string ItemName => "Pogo Stick";

		public override string itemDescription => "Jump Height +15% and slam damage +50%";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Utility };

		public override void OnStart()
		{
			jumpChange = new Change();
			new PlayerChange(null, jumpChange);
			new DamageModifier(ItemName, delegate(EnemyIdentifier eid)
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount <= 0)
				{
					return 1f;
				}
				return (eid.hitter == "ground slam") ? (1f + 0.5f * (float)itemCount) : 1f;
			});
		}

		public override void OnUpdate(int count)
		{
			jumpChange.percentage = 0.15f * (float)count;
		}

		public override void OnRemoval()
		{
			jumpChange.percentage = 0f;
		}
	}
	public class IronSights : BaseItem
	{
		private Change dmgChange;

		public override string ItemName => "Iron Sights";

		public override string itemDescription => "+6% damage per stack";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			dmgChange = new Change();
			new PlayerChange(null, null, null, null, null, null, dmgChange);
		}

		public override void OnUpdate(int count)
		{
			dmgChange.percentage = 0.06f * (float)count;
		}

		public override void OnRemoval()
		{
			dmgChange.percentage = 0f;
		}
	}
	public class GuttertankHand : BaseItem
	{
		private DamageChange damageChange;

		public override string ItemName => "Gutter tank Hand";

		public override string itemDescription => "Rocket Launcher damage +12%";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.RocketLauncher };

		public override void OnStart()
		{
			damageChange = new DamageChange(Plugin.Weapon.RocketLauncher, new Change());
			new PlayerChange(null, null, null, null, null, new List<DamageChange> { damageChange });
		}

		public override void OnUpdate(int count)
		{
			damageChange.damageChange.percentage = 0.12f * (float)count;
		}

		public override void OnRemoval()
		{
			damageChange.damageChange.percentage = 0f;
		}
	}
	public class LuckyLeaf : BaseItem
	{
		public override string ItemName => "Lucky Leaf";

		public override string itemDescription => "Luck based items are more likely to trigger";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Utility };

		public override Rarity Rarity => Rarity.Legendary;

		public override void OnGotten(int count, bool firstPickup)
		{
			Plugin.luck = count;
		}

		public override void OnRemoval()
		{
			Plugin.luck = 0;
		}
	}
	[HarmonyPatch]
	public class ToolbarsFavorite : BaseItem
	{
		[HarmonyPatch(typeof(RevolverBeam), "Start")]
		private static class StartPatch
		{
			private static void Postfix(RevolverBeam __instance)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Invalid comparison between Unknown and I4
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Invalid comparison between Unknown and I4
				if (Plugin.GetItemCount("Thunder Boomerang") != 0 && (int)__instance.beamType != 3 && (int)__instance.beamType != 2)
				{
					if ((Object)(object)__instance.previouslyHitTransform == (Object)null)
					{
						__instance.ricochetAmount *= 2;
					}
					else if (__instance.ricochetAmount == 0)
					{
						taggedBeams.Add(__instance);
					}
				}
			}
		}

		[HarmonyPatch(typeof(RevolverBeam), "HitSomething")]
		private static class HitSomethingPatch
		{
			private static void Postfix(RevolverBeam __instance, PhysicsCastResult hit)
			{
				//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 (taggedBeams.Contains(__instance) && __instance.hitAmount == 1)
				{
					SpawnExplosion(hit.point);
					taggedBeams.Remove(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(RevolverBeam), "PiercingShotCheck")]
		private static class PiercingShotCheckPatch
		{
			private static void Prefix(RevolverBeam __instance, out bool __state)
			{
				__state = __instance.fadeOut;
			}

			private static void Postfix(RevolverBeam __instance, bool __state)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if (taggedBeams.Contains(__instance) && !__state && __instance.fadeOut)
				{
					SpawnExplosion(__instance.shotHitPoint);
					taggedBeams.Remove(__instance);
				}
			}
		}

		internal static readonly HashSet<RevolverBeam> taggedBeams = new HashSet<RevolverBeam>();

		public override string ItemName => "Thunder Boomerang";

		public override string itemDescription => "Double the hitscan bounce count. Bouncing hitscan attacks explode now.";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override Rarity Rarity => Rarity.Legendary;

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Revolver };

		private static void SpawnExplosion(Vector3 point)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.explosion, point, Quaternion.identity);
			Explosion[] componentsInChildren = val.GetComponentsInChildren<Explosion>();
			foreach (Explosion val2 in componentsInChildren)
			{
				val2.canHit = (AffectedSubjects)2;
			}
		}
	}
	public class PrimeHead : BaseItem
	{
		private Change change = new Change();

		public override string ItemName => "Prime Head";

		public override string itemDescription => "Cooldowns reduce by 50%";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Utility };

		public override Rarity Rarity => Rarity.Legendary;

		public override void OnStart()
		{
			new PlayerChange(null, null, null, null, change);
		}

		public override void OnUpdate(int count)
		{
			change.percentage = 0.5f * (float)count;
		}

		public override void OnRemoval()
		{
			change.percentage = 0f;
		}
	}
	public class VinnyPimpHat : BaseItem
	{
		private float t = 0f;

		private bool wasPreviouslyFighting = false;

		private GameObject sawPrefab = null;

		public override string ItemName => "Vinny's Pimp Hat";

		public override string itemDescription => "Every 3 seconds fire a purple saw that deals 150% (+150% per stack) damage and stays until the room is cleared.";

		public override Rarity Rarity => Rarity.Legendary;

		public override void OnUpdate(int count)
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.isInRogueScene() || count <= 0)
			{
				return;
			}
			if (wasPreviouslyFighting && !Room.isFighting)
			{
				Nail[] array = Object.FindObjectsOfType<Nail>();
				Nail[] array2 = array;
				foreach (Nail val in array2)
				{
					if (val.sawblade && ((Object)((Component)val).gameObject).name.Contains("SawVinny"))
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
				}
			}
			if (Room.isFighting)
			{
				t += Time.deltaTime;
				if (t >= 3f)
				{
					if ((Object)(object)sawPrefab == (Object)null)
					{
						sawPrefab = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Modding/RogueMode/SawVinny.prefab").WaitForCompletion();
					}
					FireSaw(1.5f * (float)count);
					t = 0f;
				}
			}
			wasPreviouslyFighting = Room.isFighting;
		}

		public override void OnRemoval()
		{
			t = 0f;
			wasPreviouslyFighting = false;
			Nail[] array = Object.FindObjectsOfType<Nail>();
			Nail[] array2 = array;
			foreach (Nail val in array2)
			{
				if (val.sawblade && ((Object)((Component)val).gameObject).name.Contains("SawVinny"))
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private void FireSaw(float damage)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			float num = 2f;
			GameObject val = Object.Instantiate<GameObject>(sawPrefab, MonoSingleton<CameraController>.Instance.GetDefaultPos(), ((Component)MonoSingleton<CameraController>.Instance).transform.rotation);
			val.transform.Rotate(Random.Range((0f - num) / 3f, num / 3f), Random.Range((0f - num) / 3f, num / 3f), Random.Range((0f - num) / 3f, num / 3f));
			Rigidbody val2 = default(Rigidbody);
			if (val.TryGetComponent<Rigidbody>(ref val2))
			{
				val2.velocity = val.transform.forward * 200f;
			}
			Nail val3 = default(Nail);
			if (val.TryGetComponent<Nail>(ref val3))
			{
				val3.damage = damage;
				val3.hitAmount = float.MaxValue;
			}
			KeepInBoundsRoom keepInBoundsRoom = val.AddComponent<KeepInBoundsRoom>();
			keepInBoundsRoom.RoomInside = Room.getObjectInsideRoom(((Component)MonoSingleton<NewMovement>.Instance).transform.position);
			keepInBoundsRoom.ResetVelocity = false;
		}
	}
	public class AgonizedMask : BaseItem
	{
		public override Rarity Rarity => Rarity.Legendary;

		public override string ItemName => "Agonized Mask";

		public override string itemDescription => "Have a 25% (+10% per stack) for an enemy to spawn as a puppet (does NOT include bosses)";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Utility };
	}
	public class DualGun : BaseItem
	{
		public override Rarity Rarity => Rarity.Legendary;

		public override string ItemName => "Dual Gun";

		public override string itemDescription => "Have a 20% (+15% per stack) to get a dual wield";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Utility };
	}
	[HarmonyPatch]
	public class EyeOfGod : BaseItem
	{
		private const float BaseChance = 3f;

		private const float ChancePerHundred = 3f;

		private const float MaxChance = 75f;

		private const float BaseDamage = 3f;

		private const float DamagePerHundred = 1f;

		private const float MaxDamageMultiplier = 75f;

		private static float accumulatedDamage = 0f;

		private static Dictionary<VirtueInsignia, List<EnemyIdentifier>> alreadyHits = new Dictionary<VirtueInsignia, List<EnemyIdentifier>>();

		public override Rarity Rarity => Rarity.Legendary;

		public override string ItemName => "Eye of God";

		public override string itemDescription => "3% chance on hit to call down a virtue beam dealing 300% base damage. Every 100% damage dealt increases activation chance by 3% (+3% per stack) and beam damage by 100% (+50% per stack).";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Utility };

		public override void OnStart()
		{
			new HitEffect(ItemName, delegate(EnemyIdentifier eid, float dmg)
			{
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Expected O, but got Unknown
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount > 0 && !(eid.hitter == "fire"))
				{
					accumulatedDamage += dmg / Plugin.globalDamageMult.CalculateChanges(1f);
					int num = Mathf.FloorToInt(accumulatedDamage);
					float num2 = 3f + (float)num * 3f * (float)itemCount;
					num2 = Mathf.Min(num2, 75f);
					if (Plugin.canExecute(num2, ""))
					{
						float num3 = 3f + (float)num * 1f * (float)itemCount;
						num3 = Mathf.Min(num3, 75f);
						GameObject val = Object.Instantiate<GameObject>(AssetsManager.VirtueBeam, ((Component)eid).transform.position, Quaternion.identity);
						VirtueInsignia val2 = default(VirtueInsignia);
						if (val.TryGetComponent<VirtueInsignia>(ref val2))
						{
							val2.target = new EnemyTarget(eid);
							val2.damage = Mathf.RoundToInt(num3);
							val2.predictive = true;
							val2.windUpSpeedMultiplier = 2f;
						}
						((Object)val).name = ((Object)val).name + "God";
						accumulatedDamage = 0f;
					}
				}
			});
		}

		[HarmonyPatch(typeof(VirtueInsignia), "OnTriggerEnter")]
		public static bool Prefix(VirtueInsignia __instance, Collider other)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)((Component)__instance).gameObject).name.Contains("God"))
			{
				return true;
			}
			if (!alreadyHits.ContainsKey(__instance))
			{
				alreadyHits.Add(__instance, new List<EnemyIdentifier>());
			}
			if (__instance.target != null && (!__instance.target.isPlayer || ((Component)other).gameObject.CompareTag("Player")))
			{
				EnemyIdentifier val = ((Component)other).GetComponent<EnemyIdentifier>();
				if ((Object)(object)val == (Object)null)
				{
					EnemyIdentifierIdentifier component = ((Component)other).GetComponent<EnemyIdentifierIdentifier>();
					if ((Object)(object)component != (Object)null)
					{
						val = component.eid;
					}
				}
				Rigidbody val2 = default(Rigidbody);
				if ((Object)(object)val != (Object)null && ((Component)other).TryGetComponent<Rigidbody>(ref val2) && !alreadyHits[__instance].Contains(val))
				{
					val2.AddExplosionForce(1000f, ((Component)__instance).transform.position, 10f);
					val.SimpleDamage((float)__instance.damage);
					alreadyHits[__instance].Add(val);
				}
			}
			Flammable component2 = ((Component)other).GetComponent<Flammable>();
			if (Object.op_Implicit((Object)(object)component2) && !component2.playerOnly)
			{
				component2.Burn(10f, false);
			}
			return false;
		}
	}
	public class JumperCable : BaseItem
	{
		public override string ItemName => "Jumper Cable";

		public override string itemDescription => "Enemies have a 10% chance to be shocked when a saw blade hits them. (+5% per stack)";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override Rarity Rarity => Rarity.Legendary;

		public override void OnStart()
		{
			new HitEffect(ItemName, delegate(EnemyIdentifier eid, float dmg)
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount > 0 && !(eid.hitter != "sawblade"))
				{
					float chance = Plugin.LogarithmicChance(itemCount - 1, 0.05f, 0.1f, 0.2f) * 100f;
					if (Plugin.canExecute(chance, "", luckaffected: false))
					{
						eid.hitter = "zapper";
						eid.hitterAttributes.Add((HitterAttribute)2);
						eid.DeliverDamage(((Component)eid).gameObject, Vector3.up * 1000f, ((Component)eid).transform.position, 10f, true, 0f, (GameObject)null, false, false);
						EnemyIdentifierIdentifier[] componentsInChildren = ((Component)eid).GetComponentsInChildren<EnemyIdentifierIdentifier>();
						foreach (EnemyIdentifierIdentifier val in componentsInChildren)
						{
							Transform transform = Object.Instantiate<GameObject>(AssetsManager.zapThingy, ((Component)val).transform.position, Quaternion.identity).transform;
							transform.localScale *= 0.5f;
						}
					}
				}
			});
		}
	}
	[HarmonyPatch]
	public class ResidualCannon : BaseItem
	{
		public override string ItemName => "Residual Cannon";

		public override string itemDescription => "On hitscan fire, create a continuous beam that stays for 0.5s (+0.5s per stack) and deals 100% TOTAL damage";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override Rarity Rarity => Rarity.Legendary;

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Revolver };

		[HarmonyPatch(typeof(RevolverBeam), "Start")]
		public static void Postfix(RevolverBeam __instance)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			int itemCount = Plugin.GetItemCount("Residual Cannon");
			if (itemCount > 0 && (int)__instance.beamType != 3 && (int)__instance.beamType != 2)
			{
				GameObject val = Object.Instantiate<GameObject>(AssetsManager.mindflayerBeam, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
				ContinuousBeam val2 = default(ContinuousBeam);
				if (val.TryGetComponent<ContinuousBeam>(ref val2))
				{
					val2.damage = __instance.damage * 10f;
					val2.canHitPlayer = false;
					val2.canHitEnemy = true;
				}
				LineRenderer val3 = default(LineRenderer);
				if (val.TryGetComponent<LineRenderer>(ref val3))
				{
					val3.startColor = __instance.lr.startColor;
					val3.endColor = __instance.lr.endColor;
					val3.colorGradient = __instance.lr.colorGradient;
				}
				Object.Destroy((Object)(object)val, 0.5f * (float)itemCount);
			}
		}
	}
	public class Soulcatcher : BaseItem
	{
		private Change dmgChange;

		private float killBonus = 0f;

		public override string ItemName => "Soulcatcher";

		public override string itemDescription => "Each kill permanently increases damage by 1% up to +150% (+150% per stack)";

		public override Rarity Rarity => Rarity.Legendary;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			dmgChange = new Change();
			new PlayerChange(null, null, null, null, null, null, dmgChange);
			new DeathEffect(ItemName, delegate
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount > 0 && !(killBonus >= 1.5f * (float)itemCount))
				{
					killBonus += 0.01f;
				}
			});
		}

		public override void OnUpdate(int count)
		{
			dmgChange.percentage = killBonus;
		}

		public override void OnRemoval()
		{
			killBonus = 0f;
			dmgChange.percentage = 0f;
		}
	}
	public class CerberusHead : BaseItem
	{
		private Change dmgChange;

		public override string ItemName => "Cerberus Head";

		public override string itemDescription => "All weapons deal +70% more damage";

		public override Rarity Rarity => Rarity.Legendary;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			dmgChange = new Change();
			new PlayerChange(null, null, null, null, null, null, dmgChange);
		}

		public override void OnUpdate(int count)
		{
			dmgChange.percentage = 0.7f * (float)count;
		}

		public override void OnRemoval()
		{
			dmgChange.percentage = 0f;
		}
	}
	public class WarMachine : BaseItem
	{
		private Change atkChange;

		private Change moveChange;

		public override string ItemName => "War Machine";

		public override string itemDescription => "Attack speed +45%, move speed +20%";

		public override Rarity Rarity => Rarity.Legendary;

		public override List<ItemTag> itemTags => new List<ItemTag>
		{
			ItemTag.Damage,
			ItemTag.Utility
		};

		public override void OnStart()
		{
			atkChange = new Change();
			moveChange = new Change();
			Change attackSpeed = atkChange;
			new PlayerChange(moveChange, null, null, attackSpeed);
		}

		public override void OnUpdate(int count)
		{
			atkChange.percentage = 0.45f * (float)count;
			moveChange.percentage = 0.2f * (float)count;
		}

		public override void OnRemoval()
		{
			atkChange.percentage = 0f;
			moveChange.percentage = 0f;
		}
	}
	public class HellsFire : BaseItem
	{
		public override string ItemName => "Hell's Fire";

		public override string itemDescription => "Enemies on fire take +100% more damage";

		public override Rarity Rarity => Rarity.Legendary;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.RocketLauncher };

		public override void OnStart()
		{
			new DamageModifier(ItemName, delegate(EnemyIdentifier eid)
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount <= 0 || eid.dead || eid.hitter != "fire")
				{
					return 1f;
				}
				Flammable[] array = eid.flammables.ToArray();
				Flammable[] array2 = array;
				foreach (Flammable val in array2)
				{
					if (val.burning)
					{
						return 1f + (float)itemCount;
					}
				}
				return 1f;
			});
		}
	}
	public class MachineVirus : BaseItem
	{
		private Dictionary<EnemyIdentifier, int> hits = new Dictionary<EnemyIdentifier, int>();

		public override string ItemName => "Machine Virus";

		public override string itemDescription => "Increase damage by 0.5% for every time that enemy was hit.";

		public override Rarity Rarity => Rarity.Legendary;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			new DamageModifier(ItemName, delegate(EnemyIdentifier eid)
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount == 0)
				{
					return 1f;
				}
				int value = 0;
				if (!hits.TryGetValue(eid, out value))
				{
					hits.Add(eid, value = 1);
					value = 1;
				}
				hits[eid]++;
				return 1f + 0.005f * (float)itemCount * (float)value;
			});
		}

		public override void OnRemoval()
		{
			hits.Clear();
		}
	}
	public class IgnitionTank : BaseItem
	{
		public override string ItemName => "Ignition Tank";

		public override string itemDescription => "Fire deals 100% more damage";

		public override Rarity Rarity => Rarity.Uncommon;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			new DamageModifier(ItemName, delegate(EnemyIdentifier eid)
			{
				int itemCount = Plugin.GetItemCount(this);
				return (eid.hitter == "fire") ? ((float)(itemCount + 1)) : 1f;
			});
		}
	}
	public class RationCard : BaseItem
	{
		public override string ItemName => "Ration Card";

		public override string itemDescription => "Unlock a new area in the shop...";

		public override Rarity Rarity => Rarity.Uncommon;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Utility };

		public override bool CanOnlyHaveOne => true;
	}
	public class Executioner : BaseItem
	{
		public override string ItemName => "Executioner";

		public override string itemDescription => "Enemies below 20% HP take 100% more damage (+100% per stack)";

		public override Rarity Rarity => Rarity.Uncommon;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			new DamageModifier(ItemName, delegate(EnemyIdentifier eid)
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount <= 0)
				{
					return 1f;
				}
				float num = eid.health / ((Component)eid).GetComponent<Enemy>().originalHealth;
				return (num < 0.2f) ? (1f + 1f * (float)itemCount) : 1f;
			});
		}
	}
	public class Fusion : BaseItem
	{
		private Change hpChange;

		private float killBonus = 0f;

		public override string ItemName => "Fusion";

		public override string itemDescription => "Each kill permanently increases your max hp by 1 with a max of 50 (+50 per stack)";

		public override Rarity Rarity => Rarity.Uncommon;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Healing };

		public override void OnStart()
		{
			hpChange = new Change();
			new PlayerChange(null, null, hpChange);
			new DeathEffect(ItemName, delegate
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount > 0 && !(killBonus >= (float)(50 * itemCount)))
				{
					killBonus += 1f;
					MonoSingleton<NewMovement>.Instance.GetHealth(1, true, false, true);
				}
			});
		}

		public override void OnUpdate(int count)
		{
			hpChange.addition = killBonus;
		}

		public override void OnRemoval()
		{
			killBonus = 0f;
			hpChange.addition = 0f;
		}
	}
	public class Combatblood : BaseItem
	{
		public override string ItemName => "Combat blood";

		public override string itemDescription => "On kill, restore 3 HP (+3 per stack)";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Healing };

		public override Rarity Rarity => Rarity.Uncommon;

		public override void OnStart()
		{
			new DeathEffect(ItemName, delegate
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount > 0 && !((Object)(object)MonoSingleton<NewMovement>.Instance == (Object)null))
				{
					int num = 3 * itemCount;
					MonoSingleton<NewMovement>.Instance.hp = Mathf.Min(MonoSingleton<NewMovement>.Instance.hp + num, Plugin.MaxHealth);
				}
			});
		}
	}
	public class WillOWisp : BaseItem
	{
		[CompilerGenerated]
		private sealed class <explody>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Vector3 position;

			public WillOWisp <>4__this;

			private int <count>5__1;

			private float <radius>5__2;

			private float <damage>5__3;

			private GameObject <explosion>5__4;

			private Explosion[] <>s__5;

			private int <>s__6;

			private Explosion <exp>5__7;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <explody>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<explosion>5__4 = null;
				<>s__5 = null;
				<exp>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_0083: 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_00de: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<count>5__1 = Plugin.GetItemCount(<>4__this);
					<radius>5__2 = 6f * (float)<count>5__1;
					<damage>5__3 = 3.5f * (float)<count>5__1;
					<explosion>5__4 = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.explosion, position, Quaternion.identity);
					<>s__5 = <explosion>5__4.GetComponentsInChildren<Explosion>();
					for (<>s__6 = 0; <>s__6 < <>s__5.Length; <>s__6++)
					{
						<exp>5__7 = <>s__5[<>s__6];
						<exp>5__7.maxSize = <radius>5__2;
						<exp>5__7.canHit = (AffectedSubjects)2;
						<exp>5__7.damage = Mathf.RoundToInt(<damage>5__3);
						<exp>5__7 = null;
					}
					<>s__5 = null;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public override string ItemName => "Will-o'-the-Maurice";

		public override string itemDescription => "On kill, 35% chance to detonate the corpse for 350% damage in a 6m radius (+6m and +350% per stack)";

		public override Rarity Rarity => Rarity.Uncommon;

		public override string ItemIconName => "WillOMaurice";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			new DeathEffect(ItemName, delegate(EnemyIdentifier eid)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount > 0 && Plugin.canExecute(35f, ""))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(explody(((Component)eid).transform.position));
				}
			});
		}

		[IteratorStateMachine(typeof(<explody>d__11))]
		private IEnumerator explody(Vector3 position)
		{
			//IL_000e: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <explody>d__11(0)
			{
				<>4__this = this,
				position = position
			};
		}
	}
	[HarmonyPatch]
	public class Bouncy : BaseItem
	{
		public override string ItemName => "Bouncy Hitscans";

		public override string itemDescription => "All hitscans have a 25% (+15% chance per stack) to bounce (chance gets smaller every bounce)";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Utility };

		public override Rarity Rarity => Rarity.Uncommon;

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Revolver };

		[HarmonyPatch(typeof(RevolverBeam), "Start")]
		public static void Prefix(RevolverBeam __instance)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			int itemCount = Plugin.GetItemCount("Bouncy Hitscans");
			if (itemCount <= 0 || __instance.hasBeenRicocheter || (int)__instance.beamType == 3 || (int)__instance.beamType == 2)
			{
				return;
			}
			float num = 25f + 15f * (float)(itemCount - 1);
			float num2 = num;
			while (Plugin.canExecute(num2, ""))
			{
				__instance.ricochetAmount++;
				if (__instance.hitAmount < 2)
				{
					__instance.hitAmount = 2;
				}
				num2 /= 2f;
			}
		}
	}
	public class DeadMansHand : BaseItem
	{
		public override string ItemName => "Dead Man's Hand";

		public override string itemDescription => "Below 25% HP, deal 75% more damage (+75% per stack)";

		public override Rarity Rarity => Rarity.Uncommon;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override void OnStart()
		{
			new DamageModifier(ItemName, delegate
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount <= 0 || (Object)(object)MonoSingleton<NewMovement>.Instance == (Object)null)
				{
					return 1f;
				}
				float num = (float)MonoSingleton<NewMovement>.Instance.hp / (float)Plugin.MaxHealth;
				return (num < 0.25f) ? (1f + 0.75f * (float)itemCount) : 1f;
			});
		}
	}
	public class NailBomb : BaseItem
	{
		[CompilerGenerated]
		private sealed class <NailExplosion>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Vector3 position;

			public int count;

			public NailBomb <>4__this;

			private GameObject <explosion>5__1;

			private Explosion[] <>s__2;

			private int <>s__3;

			private Explosion <exp>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <NailExplosion>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<explosion>5__1 = null;
				<>s__2 = null;
				<exp>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<explosion>5__1 = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.explosion, position, Quaternion.identity);
					<>s__2 = <explosion>5__1.GetComponentsInChildren<Explosion>();
					for (<>s__3 = 0; <>s__3 < <>s__2.Length; <>s__3++)
					{
						<exp>5__4 = <>s__2[<>s__3];
						<exp>5__4.maxSize = 5f * (float)count;
						<exp>5__4.canHit = (AffectedSubjects)2;
						<exp>5__4.damage = Mathf.RoundToInt(1.5f * (float)count);
						<exp>5__4 = null;
					}
					<>s__2 = null;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public override string ItemName => "Nail Bomb";

		public override string itemDescription => "Nailgun kills explode for 150% damage in a 5m radius (+5m per stack)";

		public override Rarity Rarity => Rarity.Uncommon;

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Nailgun };

		public override void OnStart()
		{
			new DeathEffect(ItemName, delegate(EnemyIdentifier eid)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount > 0)
				{
					List<string> list = Plugin.WeaponToHitter(Plugin.Weapon.Nailgun);
					if (list.Contains(eid.hitter))
					{
						((MonoBehaviour)Plugin.Instance).StartCoroutine(NailExplosion(((Component)eid).transform.position, itemCount));
					}
				}
			});
		}

		[IteratorStateMachine(typeof(<NailExplosion>d__11))]
		private IEnumerator NailExplosion(Vector3 position, int count)
		{
			//IL_000e: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <NailExplosion>d__11(0)
			{
				<>4__this = this,
				position = position,
				count = count
			};
		}
	}
	public class SpikyNails : BaseItem
	{
		public override string ItemName => "Spiky Nails";

		public override string itemDescription => "Enemies with nail get +0.1% (+0.1% per stack) more damage per nail stuck in them.";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override Rarity Rarity => Rarity.Uncommon;

		public override List<Plugin.Weapon> WeaponRequirements => new List<Plugin.Weapon> { Plugin.Weapon.Nailgun };

		public override void OnStart()
		{
			new DamageModifier(ItemName, delegate(EnemyIdentifier eid)
			{
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount <= 0)
				{
					return 1f;
				}
				int nailsAmount = eid.nailsAmount;
				float num = 0.001f * (float)itemCount * (float)nailsAmount;
				return num + 1f;
			});
		}
	}
	public class MissleLauncher : BaseItem
	{
		public override string ItemName => "Missle Launcher";

		public override string itemDescription => "10% chance to launch a missile that deals 300% (+300% per stack) base damage to an enemy";

		public override List<ItemTag> itemTags => new List<ItemTag> { ItemTag.Damage };

		public override Rarity Rarity => Rarity.Uncommon;

		public override void OnStart()
		{
			new HitEffect(ItemName, delegate(EnemyIdentifier eid, float dmg)
			{
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				int itemCount = Plugin.GetItemCount(this);
				if (itemCount > 0 && Plugin.canExecute(10f, eid.hitter))
				{
					float damage = 3 * itemCount;
					GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
					val.GetComponent<Collider>().isTrigger = true;
					val.AddComponent<Rigidbody>().useGravity = false;
					Missle missle = val.AddComponent<Missle>();
					missle.damage = damage;
					missle.enemyThatGotHit = eid;
					val.transform.position = MonoSingleton<CameraController>.Instance.GetDefaultPos() + Vector3.up * 3.5f;
				}
			});
		}
	}
}
namespace Ultrarogue.Characters
{
	public abstract class BaseCharacter
	{
		public virtual List<AWeapon> StartingWeapons => new List<AWeapon>();

		public virtual List<string> StartingItems => new List<string>();

		public virtual List<Passive> Passives => new List<Passive>();

		public virtual string Name => "idk";

		public virtual string Description => "idk";

		public virtual void Update(bool selected)
		{
		}

		public virtual void OnRunStart()
		{
		}

		public bool HasPassive(Passive p)
		{
			return Passives.Contains(p);
		}
	}
	public enum Passive
	{
		HealFromBlood,
		NoFireDamage,
		TripleShot,
		GasolineFire,
		HealSetOnFire
	}
	public class RandomCharacter : BaseCharacter
	{
		private List<AWeapon> _weapons;

		private List<string> _items;

		private List<Passive> _passives;

		private PlayerChange pC = new PlayerChange();

		private bool hasReset = false;

		private static Random Rng = new Random();

		public override string Name => "Scavanger";

		public override string Description => "Start with 2 random weapons, 1 random item, and 1 random passive. <color=red>ALL YOUR STATS ARE RANDOMIZED</color>";

		public override List<AWeapon> StartingWeapons => _weapons ?? (_weapons = RollWeapons());

		public override List<string> StartingItems => _items ?? (_items = RollItems());

		public override List<Passive> Passives => _passives ?? (_passives = RollPassives());

		public override void OnRunStart()
		{
			Rng = new Random(Plugin.GameSeed.GetHashCode() - 90);
			_weapons = null;
			_passives = null;
			_items = null;
			hasReset = false;
			pC.globalDamageMult = CreateRandomChange(0.5, 1.5);
			pC.moveSpeed = CreateRandomChange(0.5);
			pC.maxHealth = CreateRandomChange(0.5);
			pC.attackSpeed = CreateRandomChange(0.5);
			pC.cooldownRed = CreateRandomChange(0.25);
		}

		public override void Update(bool selected)
		{
			if (!selected && !hasReset)
			{
				hasReset = true;
				pC.globalDamageMult = new Change();
				pC.moveSpeed = new Change();
				pC.maxHealth = new Change();
				pC.attackSpeed = new Change();
				pC.cooldownRed = new Change();
			}
		}

		private static List<AWeapon> RollWeapons()
		{
			List<Plugin.Weapon> list = Enum.GetValues(typeof(Plugin.Weapon)).Cast<Plugin.Weapon>().ToList();
			List<Plugin.Variant> list2 = Enum.GetValues(typeof(Plugin.Variant)).Cast<Plugin.Variant>().ToList();
			List<AWeapon> list3 = new List<AWeapon>();
			for (int i = 0; i < 2; i++)
			{
				Plugin.Weapon weapon = list[Rng.Next(list.Count)];
				Plugin.Variant variant = list2[Rng.Next(list2.Count)];
				bool isAlternate = AWeapon.CanBeAlternate(weapon) && Rng.NextDouble() <= 0.5;
				list3.Add(new AWeapon(weapon, variant, isAlternate));
			}
			return list3;
		}

		private static Change CreateRandomChange(double min = 0.01, double max = 2.0)
		{
			double num = min + Rng.NextDouble() * (max - min);
			return new Change(0f, 0f, (float)num);
		}

		private static List<string> RollItems()
		{
			if (Plugin.possibleItems == null || Plugin.possibleItems.Count == 0)
			{
				return new List<string>();
			}
			List<string> list = new List<string>();
			for (int i = 0; i < 1; i++)
			{
				BaseItem baseItem = Plugin.possibleItems[Rng.Next(Plugin.possibleItems.Count)];
				list.Add(baseItem.ItemName);
			}
			return list;
		}

		private static List<Passive> RollPassives()
		{
			List<Passive> list = Enum.GetValues(typeof(Passive)).Cast<Passive>().ToList();
			Passive item = list[Rng.Next(list.Count)];
			return new List<Passive> { item };
		}
	}
	public class Streetcleaner : BaseCharacter
	{
		public override string Name => "Streetcleaner";

		public override string Description => "Start with the fire starter and gasoline. All gasoline will immediately ignite. <color=red>FIRE DOES NOT HURT YOU ANYMORE</color>";

		public override List<AWeapon> StartingWeapons => new List<AWeapon>
		{
			new AWeapon(Plugin.Weapon.RocketLauncher, Plugin.Variant.Red)
		};

		public override List<string> StartingItems => new List<string> { "Gasoline" };

		public override List<Passive> Passives => new List<Passive>
		{
			Passive.GasolineFire,
			Passive.NoFireDamage,
			Passive.HealSetOnFire
		};
	}
	public class V1 : BaseCharacter
	{
		public override string Name => "V1";

		public override string Description => "Start with the piercer and feedbacker, <color=red>YOU CAN HEAL FROM BLOOD</color>.";

		public override List<AWeapon> StartingWeapons => new List<AWeapon>
		{
			new AWeapon(Plugin.Weapon.Revolver, Plugin.Variant.Blue),
			new AWeapon(Plugin.Weapon.Arm, Plugin.Variant.Blue)
		};

		public override List<Passive> Passives => new List<Passive> { Passive.HealFromBlood };
	}
	public class V2 : BaseCharacter
	{
		private Change HPChange = new Change(150f);

		private PlayerChange change;

		public override string Name => "V2";

		public override string Description => "Start with the piercer, shotgun and knuckle blaster. <color=red>YOUR REVOLVER DOES TRIPLE SHOTS</color>";

		public override List<AWeapon> StartingWeapons => new List<AWeapon>
		{
			new AWeapon(Plugin.Weapon.Revolver, Plugin.Variant.Blue),
			new AWeapon(Plugin.Weapon.Shotgun, Plugin.Variant.Blue),
			new AWeapon(Plugin.Weapon.Arm, Plugin.Variant.Green)
		};

		public override List<Passive> Passives => new List<Passive> { Passive.TripleShot };

		public override void Update(bool selected)
		{
			if (change == null)
			{
				change = new PlayerChange(null, null, HPChange);
			}
			if (selected)
			{
				HPChange.addition = 200f;
			}
			else
			{
				HPChange.addition = 0f;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}