using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Common;
using Forbidden_Catacombs.Utils;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Extensions;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.RepresentationModel;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: Guid("E0E2F92E-557C-4A05-9D89-AA92A0BD75C4")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyProduct("Forbidden_Catacombs")]
[assembly: AssemblyCompany("warpalicious")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("Forbidden_Catacombs")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyConfiguration("")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<f87061d5-2ef5-42d7-b71f-3240e8c88d9b>Embedded]
	internal sealed class <f87061d5-2ef5-42d7-b71f-3240e8c88d9b>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<f87061d5-2ef5-42d7-b71f-3240e8c88d9b>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <1866c453-a8c7-4b06-b701-c7346464b33f>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <1866c453-a8c7-4b06-b701-c7346464b33f>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <1866c453-a8c7-4b06-b701-c7346464b33f>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<f87061d5-2ef5-42d7-b71f-3240e8c88d9b>Embedded]
	internal sealed class <b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Common
{
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	public class AssetManager
	{
		public static AssetBundle assetBundle;

		public static string bundleName;

		public static void LoadAssetBundle()
		{
			assetBundle = AssetUtils.LoadAssetBundleFromResources(bundleName, Assembly.GetExecutingAssembly());
			if ((Object)(object)assetBundle == (Object)null)
			{
				WarpLogger.Logger.LogError((object)("Failed to load asset bundle with name: " + bundleName));
			}
		}
	}
	public class ConfigurationManager
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}
	}
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	public static class CreatureManager
	{
		public static void SetupCreatures(LocationManager.LocationPosition position, string creatureListName, GameObject jotunnLocationContainer, int creatureCount, string creatureYAMLContent)
		{
			if (creatureCount != 0)
			{
				if (position == LocationManager.LocationPosition.Exterior)
				{
					List<string> creatureList = CreateCreatureList(creatureListName, creatureCount, creatureYAMLContent);
					List<CreatureSpawner> exteriorCreatureSpawners = GetExteriorCreatureSpawners(jotunnLocationContainer);
					AddCreaturestoSpawnerList(exteriorCreatureSpawners, creatureList);
				}
				else
				{
					List<string> creatureList2 = CreateCreatureList(creatureListName, creatureCount, creatureYAMLContent);
					List<CreatureSpawner> interiorCreatureSpawners = GetInteriorCreatureSpawners(jotunnLocationContainer);
					AddCreaturestoSpawnerList(interiorCreatureSpawners, creatureList2);
				}
			}
		}

		public static void SetupCreatures(string creatureListName, GameObject gameObject, string creatureYAMLContent)
		{
			int count = GetCreatureSpawners(gameObject).Count;
			if (count != 0)
			{
				List<string> creatureList = CreateCreatureList(creatureListName, count, creatureYAMLContent);
				List<CreatureSpawner> creatureSpawners = GetCreatureSpawners(gameObject);
				AddCreaturestoSpawnerList(creatureSpawners, creatureList);
			}
		}

		public static List<CreatureSpawner> GetCreatureSpawners(GameObject gameObject)
		{
			return gameObject.GetComponentsInChildren<CreatureSpawner>().ToList();
		}

		public static GameObject GetCreaturePrefab(string prefabName)
		{
			GameObject prefab = Cache.GetPrefab<GameObject>(prefabName);
			if ((Object)(object)prefab != (Object)null)
			{
				return prefab;
			}
			WarpLogger.Logger.LogError((object)("Prefab not found for name:" + prefabName));
			return null;
		}

		public static void AddCreaturetoSpawner(CreatureSpawner creatureSpawner, string creaturePrefab)
		{
			GameObject creaturePrefab2 = GetCreaturePrefab(creaturePrefab);
			if ((Object)(object)creaturePrefab2 != (Object)null)
			{
				creatureSpawner.m_creaturePrefab = creaturePrefab2;
				WarpLogger.Logger.LogDebug((object)("Creature with name " + creaturePrefab + " was added to " + (object)creatureSpawner));
			}
			else
			{
				WarpLogger.Logger.LogError((object)("Creature not found for name: " + creaturePrefab));
			}
		}

		public static void AddCreaturestoSpawnerList(List<CreatureSpawner> CreatureSpawnerList, List<string> CreatureList)
		{
			int num = 0;
			foreach (CreatureSpawner CreatureSpawner in CreatureSpawnerList)
			{
				string creaturePrefab = CreatureList[num % CreatureList.Count];
				AddCreaturetoSpawner(CreatureSpawner, creaturePrefab);
				num++;
			}
		}

		public static List<CreatureSpawner> GetExteriorCreatureSpawners(GameObject location)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			List<CreatureSpawner> list = new List<CreatureSpawner>();
			CreatureSpawner[] componentsInChildren = location.GetComponentsInChildren<CreatureSpawner>();
			CreatureSpawner[] array = componentsInChildren;
			foreach (CreatureSpawner val in array)
			{
				if ((Object)(object)((Component)val).transform.parent != (Object)null && ((Component)val).transform.position.y <= 5000f)
				{
					list.Add(val);
					WarpLogger.Logger.LogDebug((object)("Exterior creature spawner found in " + ((object)location)?.ToString() + "with name: " + ((Object)val).name));
				}
			}
			return list;
		}

		public static List<CreatureSpawner> GetInteriorCreatureSpawners(GameObject location)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			List<CreatureSpawner> list = new List<CreatureSpawner>();
			CreatureSpawner[] componentsInChildren = location.GetComponentsInChildren<CreatureSpawner>();
			CreatureSpawner[] array = componentsInChildren;
			foreach (CreatureSpawner val in array)
			{
				if ((Object)(object)((Component)val).transform.parent != (Object)null && ((Component)val).transform.position.y >= 5000f)
				{
					list.Add(val);
					WarpLogger.Logger.LogDebug((object)("Interior creature spawner found in " + ((object)location)?.ToString() + " with name: " + ((Object)((Component)val).transform.parent).name));
				}
			}
			return list;
		}

		public static List<string> CreateCreatureList(string creatureListName, int creatureCount, string yamlContent)
		{
			List<string> list = new List<string>();
			YamlStream yamlStream = new YamlStream();
			yamlStream.Load(new StringReader(yamlContent));
			YamlMappingNode yamlMappingNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
			if (yamlMappingNode.Children.ContainsKey(new YamlScalarNode(creatureListName)))
			{
				YamlSequenceNode yamlSequenceNode = yamlMappingNode.Children[new YamlScalarNode(creatureListName)] as YamlSequenceNode;
				int count = yamlSequenceNode.Children.Count;
				int num = Random.Range(0, count - 1);
				for (int i = 0; i < creatureCount; i++)
				{
					int index = (num + i) % count;
					YamlScalarNode yamlScalarNode = (YamlScalarNode)yamlSequenceNode.Children[index];
					list.Add(yamlScalarNode.Value);
				}
			}
			return list;
		}

		public static List<string> CreateCreatureList(string creatureListName, string yamlContent)
		{
			List<string> list = new List<string>();
			YamlStream yamlStream = new YamlStream();
			yamlStream.Load(new StringReader(yamlContent));
			YamlMappingNode yamlMappingNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
			if (yamlMappingNode.Children.ContainsKey(new YamlScalarNode(creatureListName)))
			{
				YamlSequenceNode yamlSequenceNode = yamlMappingNode.Children[new YamlScalarNode(creatureListName)] as YamlSequenceNode;
				foreach (YamlNode child in yamlSequenceNode.Children)
				{
					if (child is YamlScalarNode yamlScalarNode)
					{
						list.Add(yamlScalarNode.Value);
					}
				}
			}
			return list;
		}
	}
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	public class LocationConfiguration
	{
		public ConfigEntry<int> Quantity { get; set; }

		public ConfigEntry<ConfigurationManager.Toggle> CreatureYaml { get; set; }

		public ConfigEntry<string> CreatureList { get; set; }

		public ConfigEntry<ConfigurationManager.Toggle> LootYaml { get; set; }

		public ConfigEntry<string> LootList { get; set; }

		public ConfigEntry<ConfigurationManager.Toggle> PickableItemYaml { get; set; }

		public ConfigEntry<string> PickableItemList { get; set; }

		public LocationConfiguration(ConfigFile config, string locationName, int spawnQuantity)
		{
			Quantity = ConfigFileExtensions.BindConfigInOrder<int>(config, locationName, "Spawn Quantity", spawnQuantity, "Amount of this location the game will attempt to place during world generation", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		}

		public LocationConfiguration(ConfigFile config, string locationName, int spawnQuantity, string customCreatureListName, string customLootListName)
		{
			Quantity = ConfigFileExtensions.BindConfigInOrder<int>(config, locationName, "Spawn Quantity", spawnQuantity, "Amount of this location the game will attempt to place during world generation", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			CreatureYaml = ConfigFileExtensions.BindConfigInOrder<ConfigurationManager.Toggle>(config, locationName, "Use Custom Creature YAML file", ConfigurationManager.Toggle.Off, "When Off, location will spawn default creatures. When On, location will select creatures from the list in the warpalicious.More_World_Locations_CreatureLists.yml file in the BepInEx config folder", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			CreatureList = ConfigFileExtensions.BindConfigInOrder<string>(config, locationName, "Name of Creature List", customCreatureListName, "The name of the creature list to use from warpalicious.More_World_Locations_CreatureLists.yml file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			LootYaml = ConfigFileExtensions.BindConfigInOrder<ConfigurationManager.Toggle>(config, locationName, "Use Custom Loot YAML file", ConfigurationManager.Toggle.Off, "When Off, location will use default loot. When On, location will select loot from the list in the warpalicious.More_World_Locations_LootLists.yml file in the BepInEx config folder", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			LootList = ConfigFileExtensions.BindConfigInOrder<string>(config, locationName, "Name of Loot List", customLootListName, "The name of the loot list to use from warpalicious.More_World_Locations_LootLists.yml file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		}

		public LocationConfiguration(ConfigFile config, string locationName, int spawnQuantity, string customCreatureListName, string customLootListName, string pickableItemListName)
		{
			Quantity = ConfigFileExtensions.BindConfigInOrder<int>(config, locationName, "Spawn Quantity", spawnQuantity, "Amount of this location the game will attempt to place during world generation", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			CreatureYaml = ConfigFileExtensions.BindConfigInOrder<ConfigurationManager.Toggle>(config, locationName, "Use Custom Creature YAML file", ConfigurationManager.Toggle.Off, "When Off, location will spawn default creatures. When On, location will select creatures from the list in the warpalicious.More_World_Locations_CreatureLists.yml file in the BepInEx config folder", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			CreatureList = ConfigFileExtensions.BindConfigInOrder<string>(config, locationName, "Name of Creature List", customCreatureListName, "The name of the creature list to use from warpalicious.More_World_Locations_CreatureLists.yml file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			LootYaml = ConfigFileExtensions.BindConfigInOrder<ConfigurationManager.Toggle>(config, locationName, "Use Custom Loot YAML file", ConfigurationManager.Toggle.Off, "When Off, location will use default loot. When On, location will select loot from the list in the warpalicious.More_World_Locations_LootLists.yml file in the BepInEx config folder", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			LootList = ConfigFileExtensions.BindConfigInOrder<string>(config, locationName, "Name of Loot List", customLootListName, "The name of the loot list to use from warpalicious.More_World_Locations_LootLists.yml file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			PickableItemYaml = ConfigFileExtensions.BindConfigInOrder<ConfigurationManager.Toggle>(config, locationName, "Use Custom PickableItem YAML file", ConfigurationManager.Toggle.Off, "When Off, location will use default loot. When On, dungeon will select loot from list in the custom YAML file in BepinEx config folder", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			PickableItemList = ConfigFileExtensions.BindConfigInOrder<string>(config, locationName, "Name of PickableItem List", pickableItemListName, "The name of the loot list to use from YAML file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
		}
	}
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	public class LocationManager
	{
		[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(0)]
		public enum LocationPosition
		{
			Interior,
			Exterior
		}

		public static LocationManager instance;

		public static LocationManager Instance => instance ?? (instance = new LocationManager());

		public static void AddLocation(AssetBundle assetBundle, string locationName, string creatureYAMLContent, string creatureListName, int creatureCount, string lootYAMLContent, string lootListName, LocationConfig locationConfig)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			GameObject val = assetBundle.LoadAsset<GameObject>(locationName);
			GameObject val2 = ZoneManager.Instance.CreateLocationContainer(val);
			CreatureManager.SetupCreatures(LocationPosition.Exterior, creatureListName, val2, creatureCount, creatureYAMLContent);
			if (LootManager.isLootListVersion2(lootYAMLContent))
			{
				List<DropData> lootList = LootManager.ParseContainerYaml_v2(lootListName, lootYAMLContent);
				List<Container> locationsContainers = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers, lootList);
			}
			else
			{
				List<string> lootList2 = LootManager.CreateLootList(lootListName, lootYAMLContent);
				List<Container> locationsContainers2 = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers2, lootList2);
				List<DropOnDestroyed> locationsDropOnDestroyeds = LootManager.GetLocationsDropOnDestroyeds(val2, LocationPosition.Exterior);
				if (locationsDropOnDestroyeds != null)
				{
					LootManager.SetupDropOnDestroyedLoot(locationsDropOnDestroyeds, lootList2);
				}
			}
			CustomLocation val3 = new CustomLocation(val2, true, locationConfig);
			ZoneManager.Instance.AddCustomLocation(val3);
		}

		public static void AddLocation(AssetBundle assetBundle, string locationName, string creatureYAMLContent, string creatureListName, string lootYAMLContent, string lootListName, LocationConfig locationConfig)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			GameObject val = assetBundle.LoadAsset<GameObject>(locationName);
			GameObject val2 = ZoneManager.Instance.CreateLocationContainer(val);
			CreatureManager.SetupCreatures(creatureListName, val2, creatureYAMLContent);
			if (LootManager.isLootListVersion2(lootYAMLContent))
			{
				List<DropData> lootList = LootManager.ParseContainerYaml_v2(lootListName, lootYAMLContent);
				List<Container> locationsContainers = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers, lootList);
			}
			else
			{
				List<string> lootList2 = LootManager.CreateLootList(lootListName, lootYAMLContent);
				List<Container> locationsContainers2 = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers2, lootList2);
			}
			CustomLocation val3 = new CustomLocation(val2, true, locationConfig);
			Debug.Log((object)("Destroying location  container with name " + ((Object)val2).name));
			ZoneManager.Instance.AddCustomLocation(val3);
		}

		public static void AddLocation(AssetBundle assetBundle, string locationName, LocationConfiguration locationConfiguration, LocationConfig locationConfig, YAMLManager yamlManager)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			GameObject val = assetBundle.LoadAsset<GameObject>(locationName);
			GameObject val2 = ZoneManager.Instance.CreateLocationContainer(val);
			CreatureManager.SetupCreatures(locationConfiguration.CreatureList.Value, val2, yamlManager.GetCreatureYamlContent(locationConfiguration.CreatureYaml.Value));
			if (LootManager.isLootListVersion2(yamlManager.GetLootYamlContent(locationConfiguration.LootYaml.Value)))
			{
				List<DropData> lootList = LootManager.ParseContainerYaml_v2(locationConfiguration.LootList.Value, yamlManager.GetLootYamlContent(locationConfiguration.LootYaml.Value));
				List<Container> locationsContainers = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers, lootList);
			}
			else
			{
				List<string> lootList2 = LootManager.CreateLootList(locationConfiguration.LootList.Value, yamlManager.GetLootYamlContent(locationConfiguration.LootYaml.Value));
				List<Container> locationsContainers2 = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers2, lootList2);
			}
			CustomLocation val3 = new CustomLocation(val2, true, locationConfig);
			ZoneManager.Instance.AddCustomLocation(val3);
		}

		public static void AddLocation(AssetBundle assetBundle, string locationName, LocationConfig locationConfig)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			GameObject val = assetBundle.LoadAsset<GameObject>(locationName);
			GameObject val2 = ZoneManager.Instance.CreateLocationContainer(val);
			CustomLocation val3 = new CustomLocation(val2, true, locationConfig);
			ZoneManager.Instance.AddCustomLocation(val3);
		}

		public static void AddLocation(AssetBundle assetBundle, string locationName, string lootYAMLContent, string lootListName, LocationConfig locationConfig)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			GameObject val = assetBundle.LoadAsset<GameObject>(locationName);
			GameObject val2 = ZoneManager.Instance.CreateLocationContainer(val);
			if (LootManager.isLootListVersion2(lootYAMLContent))
			{
				List<DropData> lootList = LootManager.ParseContainerYaml_v2(lootListName, lootYAMLContent);
				List<Container> locationsContainers = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers, lootList);
			}
			else
			{
				List<string> lootList2 = LootManager.CreateLootList(lootListName, lootYAMLContent);
				List<Container> locationsContainers2 = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers2, lootList2);
			}
			CustomLocation val3 = new CustomLocation(val2, true, locationConfig);
			ZoneManager.Instance.AddCustomLocation(val3);
		}

		public static void AddLocation(GameObject locationGameObject, LocationConfig locationConfig)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			GameObject val = ZoneManager.Instance.CreateLocationContainer(locationGameObject);
			CustomLocation val2 = new CustomLocation(val, true, locationConfig);
			ZoneManager.Instance.AddCustomLocation(val2);
		}

		public static void AddEventLocation(AssetBundle assetBundle, string locationName, string creatureYAMLContent, string creatureListName, string lootYAMLContent, string lootListName, LocationConfig locationConfig)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			GameObject val = assetBundle.LoadAsset<GameObject>(locationName);
			GameObject val2 = ZoneManager.Instance.CreateLocationContainer(val);
			CreatureManager.SetupCreatures(creatureListName, val2, creatureYAMLContent);
			if (LootManager.isLootListVersion2(lootYAMLContent))
			{
				List<DropData> lootList = LootManager.ParseContainerYaml_v2(lootListName, lootYAMLContent);
				List<Container> locationsContainers = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers, lootList);
			}
			else
			{
				List<string> lootList2 = LootManager.CreateLootList(lootListName, lootYAMLContent);
				List<Container> locationsContainers2 = LootManager.GetLocationsContainers(val2);
				LootManager.SetupChestLoot(locationsContainers2, lootList2);
			}
			GameObject gameObject = ((Component)ExposedGameObjectExtension.FindDeepChild(val2, "MWL_EventStone", (IterativeSearchType)1)).gameObject;
			if (!Object.op_Implicit((Object)(object)gameObject))
			{
				WarpLogger.Logger.LogDebug((object)"Failed to find EventStone");
			}
			gameObject.GetComponent<EffectArea>().m_statusEffect = "GoblinShaman_shield";
			CustomLocation val3 = new CustomLocation(val2, true, locationConfig);
			ZoneManager.Instance.AddCustomLocation(val3);
		}
	}
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	public static class LootManager_v2
	{
		public static void SetupContainers(GameObject gameObject, string yamlContent)
		{
			List<Container> containers = GetContainers(gameObject);
			List<DropData> drops = ParseContainerYAML(yamlContent);
			foreach (Container item in containers)
			{
				item.m_defaultItems.m_drops = drops;
			}
		}

		public static void SetupPickableItems(GameObject gameObject, string yamlContent, string listName)
		{
			List<PickableItem> pickableItems = GetPickableItems(gameObject);
			List<RandomItem> list = ParsePickableYaml(listName, yamlContent);
			RandomItem[] randomItemPrefabs = list.ToArray();
			foreach (PickableItem item in pickableItems)
			{
				item.m_randomItemPrefabs = randomItemPrefabs;
			}
		}

		public static List<DropData> ParseContainerYAML(string yamlContent)
		{
			//IL_007c: 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_00ec: 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)
			List<DropData> list = new List<DropData>();
			IDeserializer deserializer = new DeserializerBuilder().Build();
			Dictionary<string, List<Dictionary<string, object>>> dictionary = deserializer.Deserialize<Dictionary<string, List<Dictionary<string, object>>>>(yamlContent);
			foreach (List<Dictionary<string, object>> value in dictionary.Values)
			{
				foreach (Dictionary<string, object> item2 in value)
				{
					string text = item2["item"].ToString();
					GameObject prefab = Cache.GetPrefab<GameObject>(text);
					if ((Object)(object)prefab != (Object)null)
					{
						DropData val = default(DropData);
						val.m_item = prefab;
						val.m_stackMin = int.Parse(item2["stackMin"].ToString());
						val.m_stackMax = int.Parse(item2["stackMax"].ToString());
						val.m_weight = float.Parse(item2["weight"].ToString());
						val.m_dontScale = false;
						DropData item = val;
						list.Add(item);
					}
				}
			}
			return list;
		}

		public static List<RandomItem> ParsePickableYaml(string pickablelootListName, string yamlContent)
		{
			//IL_00ad: 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)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			List<RandomItem> list = new List<RandomItem>();
			IDeserializer deserializer = new DeserializerBuilder().Build();
			Dictionary<string, List<Dictionary<string, object>>> dictionary = deserializer.Deserialize<Dictionary<string, List<Dictionary<string, object>>>>(yamlContent);
			if (dictionary.ContainsKey(pickablelootListName))
			{
				WarpLogger.Logger.LogDebug((object)("Found loot list with name " + pickablelootListName + " in pickable list Yaml file"));
				foreach (Dictionary<string, object> item2 in dictionary[pickablelootListName])
				{
					string text = item2["item"].ToString();
					GameObject prefab = Cache.GetPrefab<GameObject>(text);
					if ((Object)(object)prefab != (Object)null)
					{
						ItemDrop component = prefab.GetComponent<ItemDrop>();
						if ((Object)(object)component != (Object)null)
						{
							RandomItem val = default(RandomItem);
							val.m_itemPrefab = component;
							val.m_stackMin = int.Parse(item2["stackMin"].ToString());
							val.m_stackMax = int.Parse(item2["stackMax"].ToString());
							RandomItem item = val;
							list.Add(item);
							WarpLogger.Logger.LogDebug((object)("Added item with name: " + text + " to pickable list " + pickablelootListName + " with stackMin: " + item.m_stackMin + ", stackMax: " + item.m_stackMax));
						}
					}
					else
					{
						WarpLogger.Logger.LogWarning((object)("Prefab for item " + text + " not found."));
					}
				}
			}
			else
			{
				WarpLogger.Logger.LogError((object)("Failed to find loot list with name: " + pickablelootListName + " in loot list Yaml file"));
			}
			return list;
		}

		public static List<Container> GetContainers(GameObject room)
		{
			return room.GetComponentsInChildren<Container>().ToList();
		}

		public static List<PickableItem> GetPickableItems(GameObject room)
		{
			return room.GetComponentsInChildren<PickableItem>().ToList();
		}
	}
	public class PieceManager
	{
		[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
		public static void ReplaceResourceDrops(CustomLocation location)
		{
			Piece[] componentsInChildren = location.Prefab.GetComponentsInChildren<Piece>();
			Piece[] array = componentsInChildren;
			foreach (Piece val in array)
			{
				if (!((Object)(object)((Component)val).transform.parent != (Object)null))
				{
					continue;
				}
				WarpLogger.Logger.LogDebug((object)("Piece with name " + ((object)val)?.ToString() + " found in location with name: " + (object)location));
				Requirement[] resources = val.m_resources;
				Requirement[] array2 = resources;
				foreach (Requirement val2 in array2)
				{
					if (val2 != null)
					{
						WarpLogger.Logger.LogDebug((object)("Resource with name " + ((object)val2)?.ToString() + " found in piece  with name: " + ((Object)((Component)val).transform.parent).name));
					}
				}
			}
		}
	}
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	public static class TraderManager
	{
		[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
		public class TradeItemYAML
		{
			public string PrefabName { get; set; }

			public string Action { get; set; }

			public int Quality { get; set; }

			public int Stack { get; set; }

			public int Price { get; set; }

			public string RequiredGlobalKey { get; set; }
		}

		[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
		public class SellItem
		{
			public ItemDrop m_prefab { get; set; }

			public int m_stack { get; set; }

			public int m_price { get; set; }

			public string m_requiredGlobalKey { get; set; }
		}

		public static Dictionary<string, List<TradeItem>> buyItemLists = new Dictionary<string, List<TradeItem>>();

		public static Dictionary<string, List<SellItem>> sellItemLists = new Dictionary<string, List<SellItem>>();

		public static void AddTraderBuyItems(GameObject locationContainer, List<TradeItem> traderItems)
		{
			Trader componentInChildren = locationContainer.GetComponentInChildren<Trader>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				WarpLogger.Logger.LogWarning((object)("Failed to find Trader script in location with name: " + (object)locationContainer));
			}
			else
			{
				componentInChildren.m_items = traderItems;
			}
		}

		public static void BuildBuyItemList(string traderItemYamlContent, string traderName)
		{
			//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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			List<TradeItem> list = new List<TradeItem>();
			IDeserializer deserializer = new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
			Dictionary<string, List<TradeItemYAML>> dictionary = deserializer.Deserialize<Dictionary<string, List<TradeItemYAML>>>(traderItemYamlContent);
			if (dictionary == null || !dictionary.ContainsKey(traderName))
			{
				WarpLogger.Logger.LogWarning((object)("Parsed data is null or trader name: " + traderName + " does not exist in the YAML content."));
				return;
			}
			List<TradeItemYAML> list2 = dictionary[traderName];
			foreach (TradeItemYAML item2 in list2)
			{
				GameObject prefab = Cache.GetPrefab<GameObject>(item2.PrefabName);
				if (!(item2.Action != "buy"))
				{
					ItemDrop component = prefab.GetComponent<ItemDrop>();
					if (item2.Quality != 1)
					{
						component.SetQuality(item2.Quality);
					}
					TradeItem item = new TradeItem
					{
						m_prefab = component,
						m_stack = item2.Stack,
						m_price = item2.Price,
						m_requiredGlobalKey = item2.RequiredGlobalKey
					};
					list.Add(item);
					Debug.Log((object)("Added item with name: " + item2.PrefabName + " to trader buy list with name: " + traderName));
				}
			}
			buyItemLists.Add(traderName, list);
		}

		public static void BuildSellItemList(string traderItemYamlContent, string traderName)
		{
			List<SellItem> list = new List<SellItem>();
			IDeserializer deserializer = new DeserializerBuilder().WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
			Dictionary<string, List<TradeItemYAML>> dictionary = deserializer.Deserialize<Dictionary<string, List<TradeItemYAML>>>(traderItemYamlContent);
			List<TradeItemYAML> list2 = dictionary[traderName];
			foreach (TradeItemYAML item2 in list2)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item2.PrefabName);
				if (!(item2.Action != "sell"))
				{
					ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
					if (item2.Quality != 0)
					{
						component.SetQuality(item2.Quality);
					}
					SellItem item = new SellItem
					{
						m_prefab = component,
						m_stack = item2.Stack,
						m_price = item2.Price,
						m_requiredGlobalKey = item2.RequiredGlobalKey
					};
					list.Add(item);
				}
			}
			sellItemLists.Add(traderName, list);
		}
	}
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	public class WarpLocation
	{
		public string LocationName { get; set; }

		public int SpawnQuantity { get; set; }

		public string CreatureYaml { get; set; }

		public string LootYaml { get; set; }

		public LocationConfiguration BepinExConfig { get; set; }

		public LocationConfig JotunnLocationConfig { get; set; }

		public WarpLocation(ConfigFile config, string locationName, int spawnQuantity, string creatureYaml, string lootYaml)
		{
			BepinExConfig = new LocationConfiguration(config, locationName, spawnQuantity, creatureYaml, lootYaml);
		}
	}
	public class WarpLogger
	{
		[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(1)]
		public static readonly ManualLogSource Logger = Logger.CreateLogSource("MoreWorldLocations");
	}
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	public class LootManager : MonoBehaviour
	{
		public static List<string> CreateLootList(string lootListName, string yamlContent)
		{
			YamlStream yamlStream = new YamlStream();
			yamlStream.Load(new StringReader(yamlContent));
			YamlMappingNode yamlMappingNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
			List<string> list = new List<string>();
			if (yamlMappingNode.Children.ContainsKey(new YamlScalarNode(lootListName)))
			{
				WarpLogger.Logger.LogDebug((object)("Found loot list with name " + lootListName + " in loot list Yaml file"));
				YamlSequenceNode yamlSequenceNode = yamlMappingNode.Children[new YamlScalarNode(lootListName)] as YamlSequenceNode;
				foreach (YamlNode item in yamlSequenceNode)
				{
					YamlScalarNode yamlScalarNode = item as YamlScalarNode;
					list.Add(yamlScalarNode.Value);
					WarpLogger.Logger.LogDebug((object)("Added item with name: " + item?.ToString() + " to loot list with name " + lootListName));
				}
			}
			else
			{
				WarpLogger.Logger.LogError((object)("Failed to find loot list with name: " + lootListName + " in loot list Yaml file"));
			}
			return list;
		}

		public static bool isLootListVersion2(string yamlContent)
		{
			YamlStream yamlStream = new YamlStream();
			yamlStream.Load(new StringReader(yamlContent));
			YamlMappingNode yamlMappingNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
			if (yamlMappingNode.Children.ContainsKey(new YamlScalarNode("version")))
			{
				YamlScalarNode yamlScalarNode = (YamlScalarNode)yamlMappingNode.Children[new YamlScalarNode("version")];
				string value = yamlScalarNode.Value;
				if (value == "2.0")
				{
					WarpLogger.Logger.LogDebug((object)"Version is 2");
					return true;
				}
				return false;
			}
			WarpLogger.Logger.LogDebug((object)"Version not found in YAML file");
			return false;
		}

		public static List<string> ParseContainerYaml_v1(string lootListName, string yamlContent)
		{
			YamlStream yamlStream = new YamlStream();
			yamlStream.Load(new StringReader(yamlContent));
			YamlMappingNode yamlMappingNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
			List<string> list = new List<string>();
			if (yamlMappingNode.Children.ContainsKey(new YamlScalarNode(lootListName)))
			{
				WarpLogger.Logger.LogDebug((object)("Found loot list with name " + lootListName + " in loot list Yaml file"));
				YamlSequenceNode yamlSequenceNode = yamlMappingNode.Children[new YamlScalarNode(lootListName)] as YamlSequenceNode;
				foreach (YamlNode item in yamlSequenceNode)
				{
					YamlScalarNode yamlScalarNode = item as YamlScalarNode;
					list.Add(yamlScalarNode.Value);
					WarpLogger.Logger.LogDebug((object)("Added item with name: " + item?.ToString() + " to loot list with name " + lootListName));
				}
			}
			else
			{
				WarpLogger.Logger.LogError((object)("Failed to find loot list with name: " + lootListName + " in loot list Yaml file"));
			}
			return list;
		}

		public static List<DropData> ParseContainerYaml_v2(string lootListName, string yamlContent)
		{
			//IL_0190: 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_01c4: 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)
			List<DropData> list = new List<DropData>();
			string input = RemoveVersionFromYaml(yamlContent);
			IDeserializer deserializer = new DeserializerBuilder().Build();
			Dictionary<string, List<Dictionary<string, object>>> dictionary = deserializer.Deserialize<Dictionary<string, List<Dictionary<string, object>>>>(input);
			if (dictionary.ContainsKey(lootListName))
			{
				WarpLogger.Logger.LogDebug((object)("Found loot list with name " + lootListName + " in loot list Yaml file"));
				foreach (Dictionary<string, object> item2 in dictionary[lootListName])
				{
					string text = item2["item"].ToString();
					GameObject prefab = Cache.GetPrefab<GameObject>(text);
					if ((Object)(object)prefab != (Object)null)
					{
						if (!int.TryParse(item2["stackMin"].ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
						{
							result = 2;
							WarpLogger.Logger.LogWarning((object)("Failed to parse stackMin for item " + text + ". Defaulting to " + result));
						}
						if (!int.TryParse(item2["stackMax"].ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
						{
							result2 = 3;
							WarpLogger.Logger.LogWarning((object)("Failed to parse stackMax for item " + text + ". Defaulting to " + result2));
						}
						if (!float.TryParse(item2["weight"].ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
						{
							result3 = 1f;
							WarpLogger.Logger.LogWarning((object)("Failed to parse weight for item " + text + ". Defaulting to " + result3));
						}
						DropData val = default(DropData);
						val.m_item = prefab;
						val.m_stackMin = result;
						val.m_stackMax = result2;
						val.m_weight = result3;
						val.m_dontScale = false;
						DropData item = val;
						list.Add(item);
						WarpLogger.Logger.LogDebug((object)("Added item with name: " + text + " to loot list " + lootListName + " with stackMin: " + item.m_stackMin + ", stackMax: " + item.m_stackMax + ", weight: " + item.m_weight));
					}
					else
					{
						WarpLogger.Logger.LogWarning((object)("Prefab for item " + text + " not found."));
					}
				}
			}
			else
			{
				WarpLogger.Logger.LogError((object)("Failed to find loot list with name: " + lootListName + " in loot list Yaml file"));
			}
			return list;
		}

		private static string RemoveVersionFromYaml(string yamlContent)
		{
			string[] array = yamlContent.Split(new char[1] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
			List<string> list = new List<string>();
			bool flag = false;
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (text.TrimStart(Array.Empty<char>()).StartsWith("version"))
				{
					flag = true;
				}
				else
				{
					list.Add(text);
				}
			}
			if (flag)
			{
				WarpLogger.Logger.LogDebug((object)"Version key found and removed from YAML content.");
			}
			return string.Join("\n", list);
		}

		public static List<Container> GetLocationsContainers(GameObject location)
		{
			List<Container> list = new List<Container>();
			Container[] componentsInChildren = location.GetComponentsInChildren<Container>();
			Container[] array = componentsInChildren;
			foreach (Container val in array)
			{
				list.Add(val);
				WarpLogger.Logger.LogDebug((object)("Container found in " + ((object)location)?.ToString() + "with name: " + ((Object)val).name));
			}
			return list;
		}

		public static List<Container> GetLocationsContainers(GameObject location, LocationManager.LocationPosition locationPosition)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			List<Container> list = new List<Container>();
			Container[] componentsInChildren = location.GetComponentsInChildren<Container>();
			Container[] array = componentsInChildren;
			foreach (Container val in array)
			{
				if (((Component)val).transform.position.y <= 5000f)
				{
					list.Add(val);
					WarpLogger.Logger.LogDebug((object)("Container found in " + ((object)location)?.ToString() + "with name: " + ((Object)val).name));
				}
			}
			return list;
		}

		public static void SetupChestLoot(List<Container> containerList, List<string> lootList)
		{
			foreach (Container container in containerList)
			{
				DropTable defaultItems = CreateDropTable(lootList, 2, 3);
				container.m_defaultItems = defaultItems;
				WarpLogger.Logger.LogDebug((object)("Container with name " + ((Object)container).name + " has received new dropTable"));
			}
		}

		public static void SetupChestLoot(List<Container> containerList, List<DropData> lootList)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			DropTable val = new DropTable();
			val.m_dropMin = 2;
			val.m_dropMax = 3;
			val.m_drops = lootList;
			foreach (Container container in containerList)
			{
				container.m_defaultItems = val;
				WarpLogger.Logger.LogDebug((object)("Container with name " + ((Object)container).name + " has received new dropTable"));
			}
		}

		public static List<DropOnDestroyed> GetLocationsDropOnDestroyeds(GameObject location, LocationManager.LocationPosition locationPosition)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			List<DropOnDestroyed> list = new List<DropOnDestroyed>();
			DropOnDestroyed[] componentsInChildren = location.GetComponentsInChildren<DropOnDestroyed>();
			DropOnDestroyed[] array = componentsInChildren;
			foreach (DropOnDestroyed val in array)
			{
				if (((Object)val).name.StartsWith("loot_drop") && ((Component)val).transform.position.y <= 5000f)
				{
					list.Add(val);
					WarpLogger.Logger.LogDebug((object)("DropOnDestroyed found in " + ((object)location)?.ToString() + "with name: " + ((Object)val).name));
				}
			}
			if (list.Count > 0)
			{
				return list;
			}
			return null;
		}

		public static void SetupDropOnDestroyedLoot(List<DropOnDestroyed> dropOnDestroyedList, List<string> lootList)
		{
			foreach (DropOnDestroyed dropOnDestroyed in dropOnDestroyedList)
			{
				DropTable dropWhenDestroyed = CreateDropTable(lootList, 1, 2);
				dropOnDestroyed.m_dropWhenDestroyed = dropWhenDestroyed;
			}
		}

		public static DropTable CreateDropTable(List<string> itemNames, int dropMin, int dropMax)
		{
			//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_000d: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_006a: 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_009e: 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)
			DropTable val = new DropTable
			{
				m_dropMin = dropMin,
				m_dropMax = dropMax,
				m_dropChance = 1f,
				m_oneOfEach = true
			};
			foreach (string itemName in itemNames)
			{
				WarpLogger.Logger.LogDebug((object)("Attempting to add item with name " + itemName));
				GameObject prefab = Cache.GetPrefab<GameObject>(itemName);
				if ((Object)(object)prefab != (Object)null)
				{
					DropData val2 = default(DropData);
					val2.m_item = prefab;
					val2.m_stackMin = 2;
					val2.m_stackMax = 4;
					val2.m_weight = 1f;
					val2.m_dontScale = false;
					DropData item = val2;
					val.m_drops.Add(item);
					WarpLogger.Logger.LogDebug((object)("Added item with name " + itemName));
				}
				else
				{
					WarpLogger.Logger.LogError((object)("Prefab for " + itemName + " not found"));
				}
			}
			return val;
		}

		public static void AddContainerToChild(GameObject parentGameObject, string childName, DropTable dropTable)
		{
			Transform val = parentGameObject.transform.Find(childName);
			if ((Object)(object)val != (Object)null)
			{
				Container val2 = ((Component)val).gameObject.AddComponent<Container>();
				if ((Object)(object)val2 != (Object)null)
				{
					val2.m_defaultItems = dropTable;
					val2.m_name = "Chest";
					val2.m_width = 4;
					val2.m_height = 2;
				}
			}
			else
			{
				WarpLogger.Logger.LogError((object)("Child GameObject (" + childName + ") not found in parent GameObject (" + ((object)parentGameObject)?.ToString() + ")"));
			}
		}
	}
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	public class YAMLManager
	{
		[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(0)]
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		public string creatureYAMLContent;

		public string lootYAMLContent;

		public string defaultCreatureYamlContent;

		public string customCreatureYamlContent;

		public List<string> creatureList;

		public Dictionary<string, List<string>> creatureListDictionary = new Dictionary<string, List<string>>();

		public string defaultlootYamlContent;

		public string customlootYamlContent;

		public List<DropData> lootList;

		public Dictionary<string, List<DropData>> lootListDictionary = new Dictionary<string, List<DropData>>();

		public string defaultPickableItemContent;

		public string customPickableItemContent;

		public List<RandomItem> pickableList;

		public string defaultTraderYamlContent;

		public string customTraderYamlContent;

		public void ParseDefaultYamls()
		{
			defaultCreatureYamlContent = AssetUtils.LoadTextFromResources("warpalicious.More_World_Locations_CreatureLists.yml");
			defaultlootYamlContent = AssetUtils.LoadTextFromResources("warpalicious.More_World_Locations_LootLists.yml");
		}

		public void ParseCustomYamls()
		{
			string path = Path.Combine(Paths.ConfigPath, "warpalicious.More_World_Locations_CreatureLists.yml");
			if (File.Exists(path))
			{
				customCreatureYamlContent = File.ReadAllText(path);
				WarpLogger.Logger.LogInfo((object)"Successfully loaded warpalicious.More_World_Locations_CreatureLists.yml file from BepinEx config folder");
			}
			string path2 = Path.Combine(Paths.ConfigPath, "warpalicious.More_World_Locations_LootLists.yml");
			if (File.Exists(path2))
			{
				customlootYamlContent = File.ReadAllText(path2);
				WarpLogger.Logger.LogInfo((object)"Successfully loaded warpalicious.More_World_Locations_LootLists.yml file from BepinEx config folder");
			}
		}

		public void ParseCreatureYaml(string filename)
		{
			defaultCreatureYamlContent = AssetUtils.LoadTextFromResources(filename + "_CreatureLists.yml");
			string path = Path.Combine(Paths.ConfigPath, filename + "_CreatureLists.yml");
			if (File.Exists(path))
			{
				customCreatureYamlContent = File.ReadAllText(path);
				WarpLogger.Logger.LogInfo((object)("Successfully loaded + " + filename + "_CreatureLists.yml file from BepinEx config folder"));
			}
		}

		public void ParseTraderYaml(string filename)
		{
			defaultTraderYamlContent = AssetUtils.LoadTextFromResources(filename);
			string path = Path.Combine(Paths.ConfigPath, filename);
			if (File.Exists(path))
			{
				customTraderYamlContent = File.ReadAllText(path);
				WarpLogger.Logger.LogInfo((object)("Successfully loaded + " + filename + " file from BepinEx config folder"));
			}
		}

		public void ParseContainerYaml(string filename)
		{
			defaultlootYamlContent = AssetUtils.LoadTextFromResources(filename + "_ContainerLists.yml");
			string path = Path.Combine(Paths.ConfigPath, filename + "_ContainerLists.yml");
			if (File.Exists(path))
			{
				customlootYamlContent = File.ReadAllText(path);
				WarpLogger.Logger.LogInfo((object)("Successfully loaded + " + filename + "_ContainerLists.yml file from BepinEx config folder"));
			}
		}

		public void ParsePickableItemYaml(string filename)
		{
			defaultPickableItemContent = AssetUtils.LoadTextFromResources(filename + "_PickableItemLists.yml");
			string path = Path.Combine(Paths.ConfigPath, filename + "_PickableItemLists.yml");
			if (File.Exists(path))
			{
				customPickableItemContent = File.ReadAllText(path);
				WarpLogger.Logger.LogInfo((object)("Successfully loaded + " + filename + "_PickableItemLists.yml file from BepinEx config folder"));
			}
		}

		public string GetCreatureYamlContent(ConfigurationManager.Toggle useCustomCreatureYaml)
		{
			if (useCustomCreatureYaml == ConfigurationManager.Toggle.On)
			{
				return customCreatureYamlContent;
			}
			return defaultCreatureYamlContent;
		}

		public string GetLootYamlContent(ConfigurationManager.Toggle useCustomLootYaml)
		{
			if (useCustomLootYaml == ConfigurationManager.Toggle.On)
			{
				return customlootYamlContent;
			}
			return defaultlootYamlContent;
		}

		public string GetPickableItemContent(ConfigurationManager.Toggle useCustomPickableItemYAML)
		{
			if (useCustomPickableItemYAML == ConfigurationManager.Toggle.On)
			{
				return customPickableItemContent;
			}
			return defaultPickableItemContent;
		}

		public void BuildCreatureList(ConfigurationManager.Toggle useCustomCreatureYAML, string creatureListName)
		{
			Debug.Log((object)"Test 1");
			if (useCustomCreatureYAML == ConfigurationManager.Toggle.On)
			{
				Debug.Log((object)"Test 2");
				List<string> value = CreatureManager.CreateCreatureList(creatureListName, customCreatureYamlContent);
				Debug.Log((object)"Test 3");
				creatureListDictionary.Add(creatureListName, value);
				Debug.Log((object)"Test 4");
			}
			else
			{
				Debug.Log((object)"Test 5");
				List<string> value2 = CreatureManager.CreateCreatureList(creatureListName, defaultCreatureYamlContent);
				Debug.Log((object)"Test 6");
				creatureListDictionary.Add(creatureListName, value2);
				Debug.Log((object)"Test 7");
			}
		}

		public void BuildLootList(ConfigurationManager.Toggle useCustomLootYAML, string lootListName)
		{
			if (useCustomLootYAML == ConfigurationManager.Toggle.On)
			{
				List<DropData> value = LootManager.ParseContainerYaml_v2(lootListName, customlootYamlContent);
				lootListDictionary.Add(lootListName, value);
			}
			else
			{
				List<DropData> value2 = LootManager.ParseContainerYaml_v2(lootListName, defaultlootYamlContent);
				lootListDictionary.Add(lootListName, value2);
			}
		}

		public void BuildPickableList(ConfigurationManager.Toggle useCustomPickableYAML, string pickableListName)
		{
			if (useCustomPickableYAML == ConfigurationManager.Toggle.On)
			{
				pickableList = LootManager_v2.ParsePickableYaml(pickableListName, customPickableItemContent);
			}
			else
			{
				pickableList = LootManager_v2.ParsePickableYaml(pickableListName, defaultPickableItemContent);
			}
		}
	}
}
namespace Forbidden_Catacombs
{
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	public class AltarDoor : MonoBehaviour, Interactable, Hoverable
	{
		public List<ItemStand> itemStands = new List<ItemStand>();

		public GameObject offeringItem;

		public Door targetDoor;

		public string m_name = "Sacrificial Altar";

		private ZNetView m_nview;

		private void Awake()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			m_nview = ((Component)this).GetComponent<ZNetView>();
			ZDOID zDOID = m_nview.GetZDO().GetZDOID("targetDoorZDOID");
			if (((object)(ZDOID)(ref zDOID)).ToString() != "0:0")
			{
				targetDoor = ZNetScene.instance.FindInstance(zDOID).gameObject.GetComponent<Door>();
			}
		}

		public bool Interact(Humanoid character, bool hold, bool alt)
		{
			//IL_0023: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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)
			if ((Object)(object)targetDoor == (Object)null)
			{
				GameObject val = FindGameObjectInSector("CD_kit_secretdoor", ((Component)this).gameObject.transform.position);
				if ((Object)(object)val != (Object)null)
				{
					targetDoor = val.GetComponent<Door>();
					ZDOID uid = ((Component)targetDoor).GetComponent<ZNetView>().GetZDO().m_uid;
					m_nview.GetZDO().Set("targetDoorZDOID", uid);
				}
			}
			if ((Object)(object)offeringItem == (Object)null)
			{
				return false;
			}
			if (CheckOffering())
			{
				Vector3 val2 = ((Component)character).transform.position - ((Component)this).transform.position;
				Vector3 normalized = ((Vector3)(ref val2)).normalized;
				targetDoor.Open(normalized);
				return true;
			}
			return false;
		}

		public bool CheckOffering()
		{
			List<ItemStand> list = itemStands;
			foreach (ItemStand item in list)
			{
				if (item.m_visualName != ((Object)offeringItem).name)
				{
					return false;
				}
				item.DestroyAttachment();
			}
			return true;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return true;
		}

		public string GetHoverText()
		{
			return Localization.instance.Localize(m_name + "\n[<color=yellow><b>$KEY_Use</b></color>] Sacrifice");
		}

		public string GetHoverName()
		{
			return Localization.instance.Localize(m_name);
		}

		public GameObject FindGameObjectInSector(string prefabName, Vector3 position)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			int stableHashCode = StringExtensionMethods.GetStableHashCode(prefabName);
			Vector2i zone = ZoneSystem.GetZone(position);
			int num = ZDOMan.instance.SectorToIndex(zone);
			if (num < 0 || num >= ZDOMan.instance.m_objectsBySector.Length)
			{
				return null;
			}
			List<ZDO> list = ZDOMan.instance.m_objectsBySector[num];
			if (list == null)
			{
				return null;
			}
			foreach (ZDO item in list)
			{
				int prefab = item.GetPrefab();
				if (prefab == stableHashCode)
				{
					ZNetView obj = ZNetScene.instance.FindInstance(item);
					GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			return null;
		}
	}
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	[BepInPlugin("warpalicious.Forbidden_Catacombs", "Forbidden_Catacombs", "1.0.0")]
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	public class Forbidden_CatacombsPlugin : BaseUnityPlugin
	{
		[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(0)]
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		internal const string ModName = "Forbidden_Catacombs";

		internal const string ModVersion = "1.0.0";

		internal const string Author = "warpalicious";

		private const string ModGUID = "warpalicious.Forbidden_Catacombs";

		private static string ConfigFileName = "warpalicious.Forbidden_Catacombs.cfg";

		private static string ConfigFileFullPath;

		internal static string ConnectionError;

		private readonly Harmony _harmony = new Harmony("warpalicious.Forbidden_Catacombs");

		public static readonly ManualLogSource Dungeon_CastleLogger;

		public Texture2D tex = null;

		public static YAMLManager dungeonCastleYamlManager;

		public static AssetBundle assetBundle;

		public static string bundleName;

		public static GameObject dungeonGameObject;

		public static ConfigEntry<int> MWD_CastleDungeon_Quantity;

		public static ConfigEntry<ConfigurationManager.Toggle> MWD_CastleDungeon_CreatureYaml;

		public static ConfigEntry<string> MWD_CastleDungeon_CreatureListUpper;

		public static ConfigEntry<string> MWD_CastleDungeon_CreatureListLower;

		public static ConfigEntry<ConfigurationManager.Toggle> MWD_CastleDungeon_LootYaml;

		public static ConfigEntry<string> MWD_CastleDungeon_LootListUpper;

		public static ConfigEntry<string> MWD_CastleDungeon_LootListLower;

		public static ConfigEntry<ConfigurationManager.Toggle> MWD_CastleDungeon_PickableYaml;

		public static ConfigEntry<string> MWD_CastleDungeon_PickableList;

		public static void LoadAssetBundle()
		{
			assetBundle = AssetUtils.LoadAssetBundleFromResources(bundleName, Assembly.GetExecutingAssembly());
			if ((Object)(object)assetBundle == (Object)null)
			{
				WarpLogger.Logger.LogError((object)("Failed to load asset bundle with name: " + bundleName));
			}
		}

		public void Awake()
		{
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			SetupWatcher();
			LoadAssetBundle();
			MWD_CastleDungeon_Quantity = ConfigFileExtensions.BindConfigInOrder<int>(((BaseUnityPlugin)this).Config, "Forbidden_Catacombs", "Spawn Quantity", 40, "Amount of this dungeon the game will attempt to place during world generation", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			MWD_CastleDungeon_CreatureYaml = ConfigFileExtensions.BindConfigInOrder<ConfigurationManager.Toggle>(((BaseUnityPlugin)this).Config, "Forbidden_Catacombs", "Use Custom Creature YAML file", ConfigurationManager.Toggle.Off, "When Off, location will spawn default creatures. When On, both upper and lower dungeon sections will select creatures from the list in the warpalicious.More_World_Locations_CreatureLists.yml file in the BepInEx config folder", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			MWD_CastleDungeon_CreatureListUpper = ConfigFileExtensions.BindConfigInOrder<string>(((BaseUnityPlugin)this).Config, "Forbidden_Catacombs", "Name of Creature List for Upper Section", "CatacombCreatures1", "The name of the loot list to use from warpalicious.More_World_Locations_LootLists.yml file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			MWD_CastleDungeon_CreatureListLower = ConfigFileExtensions.BindConfigInOrder<string>(((BaseUnityPlugin)this).Config, "Forbidden_Catacombs", "Name of Creature List for Lower Section", "CatacombCreatures2", "The name of the loot list to use from warpalicious.More_World_Locations_LootLists.yml file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			MWD_CastleDungeon_LootYaml = ConfigFileExtensions.BindConfigInOrder<ConfigurationManager.Toggle>(((BaseUnityPlugin)this).Config, "Forbidden_Catacombs", "Use Custom Loot YAML file", ConfigurationManager.Toggle.Off, "When Off, location will use default loot. When On, both upper and lower dungeon sections will select loot from the list in the warpalicious.More_World_Locations_LootLists.yml file in the BepInEx config folder", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			MWD_CastleDungeon_LootListUpper = ConfigFileExtensions.BindConfigInOrder<string>(((BaseUnityPlugin)this).Config, "Forbidden_Catacombs", "Name of Loot List for Upper Section", "CatacombLoot1", "The name of the loot list to use from warpalicious.More_World_Locations_LootLists.yml file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			MWD_CastleDungeon_LootListLower = ConfigFileExtensions.BindConfigInOrder<string>(((BaseUnityPlugin)this).Config, "Forbidden_Catacombs", "Name of Loot List for Lower Section", "CatacombLoot2", "The name of the loot list to use from warpalicious.More_World_Locations_LootLists.yml file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			MWD_CastleDungeon_PickableYaml = ConfigFileExtensions.BindConfigInOrder<ConfigurationManager.Toggle>(((BaseUnityPlugin)this).Config, "Forbidden_Catacombs", "Use Custom PickableItem YAML file", ConfigurationManager.Toggle.Off, "When Off, location will use default loot. When On, dungeon will select loot from list in the custom YAML file in BepinEx config folder", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			MWD_CastleDungeon_PickableList = ConfigFileExtensions.BindConfigInOrder<string>(((BaseUnityPlugin)this).Config, "Forbidden_Catacombs", "Name of PickableItem List", "CatacombPickables1", "The name of the loot list to use from YAML file", true, true, true, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, (ConfigurationManagerAttributes)null);
			dungeonGameObject = assetBundle.LoadAsset<GameObject>("CD_Exterior1");
			Rooms.RegisterTheme(dungeonGameObject, "CD_Catacomb");
			dungeonCastleYamlManager.ParseDefaultYamls();
			dungeonCastleYamlManager.ParseCustomYamls();
			dungeonCastleYamlManager.ParsePickableItemYaml("warpalicious.More_World_Locations");
			TranslationUtils.AddLocalizations();
			PrefabManager.OnVanillaPrefabsAvailable += BuildYamlLists;
			PrefabManager.OnVanillaPrefabsAvailable += CustomPrefabs.RegisterKitPrefabs;
			ZoneManager.OnVanillaLocationsAvailable += Locations.AddAllLocations;
			DungeonManager.OnVanillaRoomsAvailable += Rooms.AddAllRooms;
			if (saveOnConfigSet)
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
				((BaseUnityPlugin)this).Config.Save();
			}
		}

		public void BuildYamlLists()
		{
			dungeonCastleYamlManager.BuildCreatureList(MWD_CastleDungeon_CreatureYaml.Value, MWD_CastleDungeon_CreatureListUpper.Value);
			dungeonCastleYamlManager.BuildCreatureList(MWD_CastleDungeon_CreatureYaml.Value, MWD_CastleDungeon_CreatureListLower.Value);
			dungeonCastleYamlManager.BuildLootList(MWD_CastleDungeon_LootYaml.Value, MWD_CastleDungeon_LootListUpper.Value);
			dungeonCastleYamlManager.BuildLootList(MWD_CastleDungeon_LootYaml.Value, MWD_CastleDungeon_LootListLower.Value);
			dungeonCastleYamlManager.BuildPickableList(MWD_CastleDungeon_PickableYaml.Value, MWD_CastleDungeon_PickableList.Value);
			PrefabManager.OnVanillaPrefabsAvailable -= BuildYamlLists;
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				Dungeon_CastleLogger.LogDebug((object)"ReadConfigValues called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				Dungeon_CastleLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
				Dungeon_CastleLogger.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		static Forbidden_CatacombsPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			Dungeon_CastleLogger = Logger.CreateLogSource("Forbidden_Catacombs");
			dungeonCastleYamlManager = new YAMLManager();
			bundleName = "dungeoncastle";
		}
	}
	public static class KeyboardExtensions
	{
		public static bool IsKeyDown(this KeyboardShortcut shortcut)
		{
			//IL_0003: 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)
			return (int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
		}

		public static bool IsKeyHeld(this KeyboardShortcut shortcut)
		{
			//IL_0003: 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)
			return (int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
		}
	}
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	public class CustomPrefabs
	{
		public static void RegisterKitPrefabs()
		{
			Logger.LogDebug((object)"RegisterKitPrefabs invoked");
			List<string> list = new List<string>
			{
				"CD_kit_stone_arch.prefab", "CD_kit_stone_floor.prefab", "CD_kit_stone_floor_2x2.prefab", "CD_kit_stone_pillar.prefab", "CD_kit_stone_stair.prefab", "CD_kit_stone_wall_1x1.prefab", "CD_kit_stone_wall_2x1.prefab", "CD_kit_stone_wall_4x2.prefab", "CD_kit_iron_floor_1x1", "CD_kit_iron_floor_2x2",
				"CD_kit_fi_vil_cath_decor_swords_cross", "CD_kit_fi_vil_shield05_a", "CD_kit_dungeon_sunkencrypt_irongate_rusty", "CD_kit_crypt_skeleton_chest", "CD_kit_water", "CD_kit_altarHolder", "CD_kit_secretdoor", "CD_kit_AltarDoor", "CD_kit_SunkenKit_int_wall_4x4", "CD_kit_SunkenKit_int_wall_2x4",
				"CD_kit_SunkenKit_int_floor_4x4", "CD_kit_SunkenKit_int_arch", "CD_kit_SunkenKit_int_stair", "CD_kit_sunken_crypt_gate", "CD_kit_Spawner_DraugrPile", "CD_kit_CastleKit_groundtorch", "CD_kit_CastleKit_groundtorch_green", "CD_kit_CryptKey"
			};
			List<string> list2 = new List<string>
			{
				"CD_Room1_Spawner1", "CD_Room2_Spawner1", "CD_RoomBig1_Spawner1", "CD_RoomBig1_Spawner2", "CD_RoomBig1_Spawner3", "CD_RoomBig1_Spawner4", "CD_RoomBig2_Spawner1", "CD_RoomBig2_Spawner2", "CD_RoomBig3_Spawner1", "CD_RoomBig3_Spawner2",
				"CD_RoomBig3_Spawner3", "CD_RoomBig3_Spawner4"
			};
			List<string> list3 = new List<string> { "CD_Lower_Hallway2_Spawner1", "CD_Lower_Hallway2_Spawner2", "CD_Lower_Hallway4_Spawner1", "CD_Lower_Room1_Spawner1" };
			List<string> list4 = new List<string> { "CD_Endcap14_loot_chest_stone1", "CD_Room2_loot_chest_stone1", "CD_RoomBig1_loot_chest_stone1", "CD_RoomBig2_loot_chest_stone1" };
			List<string> list5 = new List<string> { "CD_Lower_Room1_loot_chest_stone1" };
			List<string> list6 = new List<string>();
			foreach (string item in list)
			{
				RegisterCustomPrefab(Forbidden_CatacombsPlugin.assetBundle, item);
			}
			foreach (string item2 in list2)
			{
				List<string> list7 = Forbidden_CatacombsPlugin.dungeonCastleYamlManager.creatureListDictionary[Forbidden_CatacombsPlugin.MWD_CastleDungeon_CreatureListUpper.Value];
				int index = Random.Range(0, list7.Count);
				RegisterCustomPrefabSpawner(Forbidden_CatacombsPlugin.assetBundle, item2, list7[index]);
			}
			foreach (string item3 in list3)
			{
				List<string> list8 = Forbidden_CatacombsPlugin.dungeonCastleYamlManager.creatureListDictionary[Forbidden_CatacombsPlugin.MWD_CastleDungeon_CreatureListLower.Value];
				int index2 = Random.Range(0, list8.Count);
				RegisterCustomPrefabSpawner(Forbidden_CatacombsPlugin.assetBundle, item3, list8[index2]);
			}
			foreach (string item4 in list4)
			{
				List<DropData> dropData = Forbidden_CatacombsPlugin.dungeonCastleYamlManager.lootListDictionary[Forbidden_CatacombsPlugin.MWD_CastleDungeon_LootListUpper.Value];
				RegisterCustomPrefabContainer(Forbidden_CatacombsPlugin.assetBundle, item4, dropData);
			}
			foreach (string item5 in list5)
			{
				List<DropData> dropData2 = Forbidden_CatacombsPlugin.dungeonCastleYamlManager.lootListDictionary[Forbidden_CatacombsPlugin.MWD_CastleDungeon_LootListLower.Value];
				RegisterCustomPrefabContainer(Forbidden_CatacombsPlugin.assetBundle, item5, dropData2);
			}
			PrefabManager.OnVanillaPrefabsAvailable -= RegisterKitPrefabs;
		}

		public static GameObject RegisterCustomPrefab(AssetBundle bundle, string assetName)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			string value = assetName.Replace(".prefab", "");
			if (!string.IsNullOrEmpty(value))
			{
				CustomPrefab val = new CustomPrefab(bundle, assetName, true);
				Logger.LogDebug((object)("Registering " + ((Object)val.Prefab).name));
				if (val != null && val.IsValid())
				{
					PrefabExtension.FixReferences(val.Prefab, true);
					PrefabManager.Instance.AddPrefab(val);
					return val.Prefab;
				}
			}
			return null;
		}

		public static GameObject RegisterCustomPrefabSpawner(AssetBundle bundle, string assetName, string creatureName)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			string value = assetName.Replace(".prefab", "");
			if (!string.IsNullOrEmpty(value))
			{
				CustomPrefab val = new CustomPrefab(bundle, assetName, true);
				Logger.LogDebug((object)("Registering " + ((Object)val.Prefab).name));
				if (val != null && val.IsValid())
				{
					CreatureSpawner component = val.Prefab.GetComponent<CreatureSpawner>();
					component.m_creaturePrefab = Cache.GetPrefab<GameObject>(creatureName);
					PrefabExtension.FixReferences(val.Prefab, true);
					PrefabManager.Instance.AddPrefab(val);
					return val.Prefab;
				}
			}
			return null;
		}

		public static GameObject RegisterCustomPrefabContainer(AssetBundle bundle, string assetName, List<DropData> dropData)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			string value = assetName.Replace(".prefab", "");
			if (!string.IsNullOrEmpty(value))
			{
				CustomPrefab val = new CustomPrefab(bundle, assetName, true);
				Logger.LogDebug((object)("Registering " + ((Object)val.Prefab).name));
				if (val != null && val.IsValid())
				{
					Container component = val.Prefab.GetComponent<Container>();
					component.m_defaultItems.m_drops = dropData;
					PrefabExtension.FixReferences(val.Prefab, true);
					PrefabManager.Instance.AddPrefab(val);
					return val.Prefab;
				}
			}
			return null;
		}

		public static GameObject RegisterCustomPrefabRandomItem(AssetBundle bundle, string assetName, List<RandomItem> randomItems)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			string value = assetName.Replace(".prefab", "");
			if (!string.IsNullOrEmpty(value))
			{
				CustomPrefab val = new CustomPrefab(bundle, assetName, true);
				Logger.LogDebug((object)("Registering " + ((Object)val.Prefab).name));
				if (val != null && val.IsValid())
				{
					RandomItem[] randomItemPrefabs = randomItems.ToArray();
					PickableItem component = val.Prefab.GetComponent<PickableItem>();
					component.m_randomItemPrefabs = randomItemPrefabs;
					PrefabExtension.FixReferences(val.Prefab, true);
					PrefabManager.Instance.AddPrefab(val);
					return val.Prefab;
				}
			}
			return null;
		}
	}
	public class LocationConfigs
	{
		public struct LocationRing
		{
			public int MinDistance { get; set; }

			public int MaxDistance { get; set; }

			public LocationRing(int minDistance, int maxDistance)
			{
				MinDistance = minDistance;
				MaxDistance = maxDistance;
			}
		}

		public static class LocationRings
		{
			public static LocationRing Ring1 { get; set; } = new LocationRing(0, 500);


			public static LocationRing Ring2 { get; set; } = new LocationRing(500, 2000);


			public static LocationRing Ring3 { get; set; } = new LocationRing(1500, 3000);


			public static LocationRing Ring4 { get; set; } = new LocationRing(2500, 4000);


			public static LocationRing Ring5 { get; set; } = new LocationRing(3500, 6000);


			public static LocationRing Ring6 { get; set; } = new LocationRing(4500, 8500);


			public static LocationRing Ring7 { get; set; } = new LocationRing(5000, 10500);

		}

		[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(1)]
		public static LocationConfig MWD_Castle_Config = new LocationConfig
		{
			Biome = (Biome)2,
			BiomeArea = (BiomeArea)3,
			Quantity = Forbidden_CatacombsPlugin.MWD_CastleDungeon_Quantity.Value,
			Priotized = true,
			ExteriorRadius = 12f,
			ClearArea = true,
			SlopeRotation = true,
			RandomRotation = false,
			Group = "Dungeon_Catacomb",
			MinDistanceFromSimilar = 512f,
			MinTerrainDelta = 0.3f,
			MinAltitude = 2f,
			MinDistance = LocationRings.Ring2.MinDistance
		};
	}
	public class Locations
	{
		public static void AddAllLocations()
		{
			LocationManager.AddLocation(Forbidden_CatacombsPlugin.dungeonGameObject, LocationConfigs.MWD_Castle_Config);
			ZoneManager.OnVanillaLocationsAvailable -= AddAllLocations;
		}
	}
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	public class Rooms
	{
		public static Dictionary<string, RoomConfig> UpperRoomConfigs = new Dictionary<string, RoomConfig>
		{
			{
				"CD_Entrance2",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Entrance = true,
					Weight = 1f
				}
			},
			{
				"CD_Room1",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Room2",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Room3",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Room4",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_RoomBig1",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_RoomBig2",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_RoomBig3",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Hallway1",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Hallway2",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Hallway3",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Endcap1",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap2",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap4",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap5",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap6",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap7",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap8",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap9",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap10",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap11",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap12",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap13",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Endcap14",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			}
		};

		public static Dictionary<string, RoomConfig> LowerRoomConfigs = new Dictionary<string, RoomConfig>
		{
			{
				"CD_Lower_Hallway1",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Hallway2",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Hallway3",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Hallway4",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Room1",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Room2",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Room3",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Cell1",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Cell2",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Cell3",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Weight = 1f
				}
			},
			{
				"CD_Lower_Endcap1",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Lower_Endcap2",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Lower_Endcap3",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			},
			{
				"CD_Lower_Endcap4",
				new RoomConfig
				{
					ThemeName = "CD_Catacomb",
					Endcap = true,
					EndcapPrio = 0,
					Weight = 1f
				}
			}
		};

		public static void AddAllRooms()
		{
			AssetBundle assetBundle = Forbidden_CatacombsPlugin.assetBundle;
			foreach (KeyValuePair<string, RoomConfig> upperRoomConfig in UpperRoomConfigs)
			{
				AddRoom(assetBundle, upperRoomConfig.Key, upperRoomConfig.Value, Forbidden_CatacombsPlugin.dungeonCastleYamlManager.GetCreatureYamlContent(Forbidden_CatacombsPlugin.MWD_CastleDungeon_CreatureYaml.Value), Forbidden_CatacombsPlugin.MWD_CastleDungeon_CreatureListUpper.Value, Forbidden_CatacombsPlugin.dungeonCastleYamlManager.GetLootYamlContent(Forbidden_CatacombsPlugin.MWD_CastleDungeon_LootYaml.Value), Forbidden_CatacombsPlugin.MWD_CastleDungeon_LootListUpper.Value, Forbidden_CatacombsPlugin.dungeonCastleYamlManager.GetPickableItemContent(Forbidden_CatacombsPlugin.MWD_CastleDungeon_PickableYaml.Value), Forbidden_CatacombsPlugin.MWD_CastleDungeon_PickableList.Value);
			}
			foreach (KeyValuePair<string, RoomConfig> lowerRoomConfig in LowerRoomConfigs)
			{
				AddRoom(assetBundle, lowerRoomConfig.Key, lowerRoomConfig.Value, Forbidden_CatacombsPlugin.dungeonCastleYamlManager.GetCreatureYamlContent(Forbidden_CatacombsPlugin.MWD_CastleDungeon_CreatureYaml.Value), Forbidden_CatacombsPlugin.MWD_CastleDungeon_CreatureListLower.Value, Forbidden_CatacombsPlugin.dungeonCastleYamlManager.GetLootYamlContent(Forbidden_CatacombsPlugin.MWD_CastleDungeon_LootYaml.Value), Forbidden_CatacombsPlugin.MWD_CastleDungeon_LootListLower.Value, Forbidden_CatacombsPlugin.dungeonCastleYamlManager.GetPickableItemContent(Forbidden_CatacombsPlugin.MWD_CastleDungeon_PickableYaml.Value), Forbidden_CatacombsPlugin.MWD_CastleDungeon_PickableList.Value);
			}
			DungeonManager.OnVanillaRoomsAvailable -= AddAllRooms;
		}

		public static void RegisterTheme(GameObject dungeonGameObject, string themeName)
		{
			if (DungeonManager.Instance.RegisterDungeonTheme(dungeonGameObject, themeName))
			{
				WarpLogger.Logger.LogDebug((object)("RoomTheme with name " + themeName + " was successfully registered to " + (object)dungeonGameObject));
			}
			else
			{
				WarpLogger.Logger.LogError((object)("RoomTheme with name " + themeName + " failed to register"));
			}
		}

		public static void AddRoom(AssetBundle assetBundle, string prefabName, RoomConfig roomConfig, string creatureYAMLContent, string creatureListName, string lootYAMLContent, string lootListName, string pickableItemYAMLContent, string pickableListName)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			GameObject val = assetBundle.LoadAsset<GameObject>(prefabName);
			GameObject val2 = ZoneManager.Instance.CreateLocationContainer(val);
			List<DropData> lootList = LootManager.ParseContainerYaml_v2(lootListName, lootYAMLContent);
			List<Container> locationsContainers = LootManager.GetLocationsContainers(val2);
			LootManager.SetupChestLoot(locationsContainers, lootList);
			LootManager_v2.SetupPickableItems(val2, pickableItemYAMLContent, pickableListName);
			CreatureManager.SetupCreatures(creatureListName, val2, creatureYAMLContent);
			CustomRoom val3 = new CustomRoom(val2, true, roomConfig);
			DungeonManager.Instance.AddCustomRoom(val3);
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			Forbidden_CatacombsPlugin.Dungeon_CastleLogger.LogDebug((object)"Registering version RPC handler");
			peer.m_rpc.Register<ZPackage>("Forbidden_Catacombs_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_Dungeon_Castle_Version);
			Forbidden_CatacombsPlugin.Dungeon_CastleLogger.LogDebug((object)"Invoking version check");
			ZPackage val = new ZPackage();
			val.Write("1.0.0");
			peer.m_rpc.Invoke("Forbidden_Catacombs_VersionCheck", new object[1] { val });
		}
	}
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	public static class VerifyClient
	{
		private static bool Prefix(ZRpc rpc, ZPackage pkg, ref ZNet __instance)
		{
			if (!__instance.IsServer() || RpcHandlers.ValidatedPeers.Contains(rpc))
			{
				return true;
			}
			Forbidden_CatacombsPlugin.Dungeon_CastleLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") never sent version or couldn't due to previous disconnect, disconnecting"));
			rpc.Invoke("Error", new object[1] { 3 });
			return false;
		}

		private static void Postfix(ZNet __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "Forbidden_CatacombsRequestAdminSync", new object[1] { (object)new ZPackage() });
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	public class ShowConnectionError
	{
		[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
		private static void Postfix(FejdStartup __instance)
		{
			if (__instance.m_connectionFailedPanel.activeSelf)
			{
				__instance.m_connectionFailedError.fontSizeMax = 25f;
				__instance.m_connectionFailedError.fontSizeMin = 15f;
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + Forbidden_CatacombsPlugin.ConnectionError;
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (__instance.IsServer())
			{
				Forbidden_CatacombsPlugin.Dungeon_CastleLogger.LogInfo((object)("Peer (" + peer.m_rpc.m_socket.GetHostName() + ") disconnected, removing from validated list"));
				RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(0)]
	[<b9c9e924-0acc-473b-8cdd-2aa4aa6c8aa9>NullableContext(1)]
	public static class RpcHandlers
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void RPC_Dungeon_Castle_Version(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			Forbidden_CatacombsPlugin.Dungeon_CastleLogger.LogInfo((object)("Version check, local: 1.0.0,  remote: " + text));
			if (text != "1.0.0")
			{
				Forbidden_CatacombsPlugin.ConnectionError = "Forbidden_Catacombs Installed: 1.0.0\n Needed: " + text;
				if (ZNet.instance.IsServer())
				{
					Forbidden_CatacombsPlugin.Dungeon_CastleLogger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") has incompatible version, disconnecting..."));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (!ZNet.instance.IsServer())
			{
				Forbidden_CatacombsPlugin.Dungeon_CastleLogger.LogInfo((object)"Received same version from server!");
			}
			else
			{
				Forbidden_CatacombsPlugin.Dungeon_CastleLogger.LogInfo((object)("Adding peer (" + rpc.m_socket.GetHostName() + ") to validated list"));
				ValidatedPeers.Add(rpc);
			}
		}
	}
}
namespace Forbidden_Catacombs.Utils
{
	public class TranslationUtils
	{
		[<1866c453-a8c7-4b06-b701-c7346464b33f>Nullable(1)]
		public static CustomLocalization Localization;

		public static void AddLocalizations()
		{
			Localization = LocalizationManager.Instance.GetLocalization();
			CustomLocalization localization = Localization;
			string text = "English";
			localization.AddTranslation(ref text, new Dictionary<string, string> { { "catacomb_hint", "Ancient Seal" } });
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	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]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace YamlDotNet
{
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.LCID)
		{
			this.provider = provider;
		}

		public override object? GetFormat(Type? formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	internal static class ReflectionExtensions
	{
		private static readonly FieldInfo? RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

		public static Type? BaseType(this Type type)
		{
			return type.BaseType;
		}

		public static bool IsValueType(this Type type)
		{
			return type.IsValueType;
		}

		public static bool IsGenericType(this Type type)
		{
			return type.IsGenericType;
		}

		public static bool IsGenericTypeDefinition(this Type type)
		{
			return type.IsGenericTypeDefinition;
		}

		public static bool IsInterface(this Type type)
		{
			return type.IsInterface;
		}

		public static bool IsEnum(this Type type)
		{
			return type.IsEnum;
		}

		public static bool IsDbNull(this object value)
		{
			return value is DBNull;
		}

		public static bool HasDefaultConstructor(this Type type, bool allowPrivateConstructors)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (allowPrivateConstructors)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsValueType)
			{
				return type.GetConstructor(bindingFlags, null, Type.EmptyTypes, null) != null;
			}
			return true;
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			return Type.GetTypeCode(type);
		}

		public static PropertyInfo? GetPublicProperty(this Type type, string name)
		{
			return type.GetProperty(name);
		}

		public static FieldInfo? GetPublicStaticField(this Type type, string name)
		{
			return type.GetField(name, BindingFlags.Static | BindingFlags.Public);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (includeNonPublic)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsInterface)
			{
				return type.GetProperties(bindingFlags);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany((Type i) => i.GetProperties(bindingFlags));
		}

		public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
		{
			return type.GetProperties(includeNonPublic: false);
		}

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return type.GetFields(BindingFlags.Instance | BindingFlags.Public);
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return type.GetMethods(BindingFlags.Static | BindingFlags.Public);
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.NonPublic) ?? throw new MissingMethodException("Expected to find a method named '" + name + "' in '" + type.FullName + "'.");
		}

		public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
		}

		public static MethodInfo? GetPublicInstanceMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public);
		}

		public static Exception Unwrap(this TargetInvocationException ex)
		{
			Exception innerException = ex.InnerException;
			if (innerException == null)
			{
				return ex;
			}
			if (RemoteStackTraceField != null)
			{
				RemoteStackTraceField.SetValue(innerException, innerException.StackTrace + "\r\n");
			}
			return innerException;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			return type.IsInstanceOfType(o);
		}

		public static Attribute[] GetAllCustomAttributes<TAttribute>(this PropertyInfo property)
		{
			return Attribute.GetCustomAttributes(property, typeof(TAttribute), inherit: true);
		}
	}
	internal static class PropertyInfoExtensions
	{
		public static object? ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	internal abstract class BuilderSkeleton<TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly YamlAttributeOverrides overrides;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool ignoreFields;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		protected abstract TBuilder Self { get; }

		internal BuilderSkeleton(ITypeResolver typeResolver)
		{
			overrides = new YamlAttributeOverrides();
			typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter>
			{
				{
					typeof(YamlDotNet.Serialization.Converters.GuidConverter),
					(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
				},
				{
					typeof(SystemTypeConverter),
					(Nothing _) => new SystemTypeConverter()
				}
			};
			typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

		public TBuilder IgnoreFields()
		{
			ignoreFields = true;
			return Self;
		}

		public TBuilder IncludeNonPublicProperties()
		{
			includeNonPublicProperties = true;
			return Self;
		}

		public TBuilder EnablePrivateConstructors()
		{
			settings.AllowPrivateConstructors = true;
			return Self;
		}

		public TBuilder WithNamingConvention(INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(TagName tag, Type type);

		public TBuilder WithAttributeOverride<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			overrides.Add(propertyAccessor, attribute);
			return Self;
		}

		public TBuilder WithAttributeOverride(Type type, string member, Attribute attribute)
		{
			overrides.Add(type, member, attribute);
			return Self;
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
		{
			IYamlTypeConverter typeConverter2 = typeConverter;
			if (typeConverter2 == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

		public TBuilder WithoutTypeConverter(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			typeConverterFactories.Remove(converterType);
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTra