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.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Common;
using HarmonyLib;
using JetBrains.Annotations;
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("Meadows_Pack_2")]
[assembly: AssemblyCompany("warpalicious")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("Meadows_Pack_2")]
[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]
	[<815b508b-c26f-4898-83c9-533b3424f243>Embedded]
	internal sealed class <815b508b-c26f-4898-83c9-533b3424f243>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<815b508b-c26f-4898-83c9-533b3424f243>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <b642bea3-0317-4081-beee-8d1bf9cc2c0d>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <b642bea3-0317-4081-beee-8d1bf9cc2c0d>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <b642bea3-0317-4081-beee-8d1bf9cc2c0d>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<815b508b-c26f-4898-83c9-533b3424f243>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Common
{
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>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
		}
	}
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	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;
		}
	}
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>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);
		}
	}
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	public class LocationManager
	{
		[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(0)]
		public enum LocationPosition
		{
			Interior,
			Exterior
		}

		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);
			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);
		}
	}
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	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
	{
		[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>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));
					}
				}
			}
		}
	}
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	public static class TraderManager
	{
		[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>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; }
		}

		[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>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);
		}
	}
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>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
	{
		[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(1)]
		public static readonly ManualLogSource Logger = Logger.CreateLogSource("MoreWorldLocations");
	}
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	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() + ")"));
			}
		}
	}
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	public class YAMLManager
	{
		[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>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 string defaultlootYamlContent;

		public string customlootYamlContent;

		public List<DropData> lootList;

		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)
		{
			if (useCustomCreatureYAML == ConfigurationManager.Toggle.On)
			{
				creatureList = CreatureManager.CreateCreatureList(creatureListName, customCreatureYamlContent);
			}
			else
			{
				creatureList = CreatureManager.CreateCreatureList(creatureListName, defaultCreatureYamlContent);
			}
		}

		public void BuildLootList(ConfigurationManager.Toggle useCustomLootYAML, string lootListName)
		{
			if (useCustomLootYAML == ConfigurationManager.Toggle.On)
			{
				lootList = LootManager.ParseContainerYaml_v2(lootListName, customlootYamlContent);
			}
			else
			{
				lootList = LootManager.ParseContainerYaml_v2(lootListName, defaultlootYamlContent);
			}
		}

		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 Meadows_Pack_2
{
	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);

		}

		[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(1)]
		public static Dictionary<string, LocationConfig> AllLocationConfigs = new Dictionary<string, LocationConfig>
		{
			{
				"MWL_DeerShrine1_Config",
				new LocationConfig
				{
					Quantity = Meadows_Pack_2Plugin.MWL_DeerShrine1_Configuration.Quantity.Value,
					Biome = (Biome)1,
					BiomeArea = (BiomeArea)3,
					Group = "Ruins_shrine",
					Priotized = true,
					RandomRotation = false,
					MinDistanceFromSimilar = 1024f,
					MaxTerrainDelta = 2f,
					MinAltitude = 1f,
					MinDistance = LocationRings.Ring1.MinDistance,
					MaxDistance = LocationRings.Ring3.MaxDistance,
					InForest = false
				}
			},
			{
				"MWL_DeerShrine2_Config",
				new LocationConfig
				{
					Quantity = Meadows_Pack_2Plugin.MWL_DeerShrine2_Configuration.Quantity.Value,
					Biome = (Biome)1,
					BiomeArea = (BiomeArea)3,
					Group = "Ruins_shrine",
					Priotized = true,
					RandomRotation = false,
					MinDistanceFromSimilar = 1024f,
					MaxTerrainDelta = 2f,
					MinAltitude = 1f,
					MinDistance = LocationRings.Ring4.MinDistance,
					InForest = false
				}
			},
			{
				"MWL_MeadowsBarn1_Config",
				new LocationConfig
				{
					Quantity = Meadows_Pack_2Plugin.MWL_MeadowsBarn1_Configuration.Quantity.Value,
					Biome = (Biome)1,
					BiomeArea = (BiomeArea)2,
					Group = "Wood_small",
					Priotized = true,
					RandomRotation = false,
					MinDistanceFromSimilar = 512f,
					MaxTerrainDelta = 3f,
					MinAltitude = 1f,
					MinDistance = LocationRings.Ring1.MinDistance,
					MaxDistance = LocationRings.Ring2.MaxDistance,
					InForest = false
				}
			},
			{
				"MWL_MeadowsHouse2_Config",
				new LocationConfig
				{
					Quantity = Meadows_Pack_2Plugin.MWL_MeadowsHouse2_Configuration.Quantity.Value,
					Biome = (Biome)1,
					BiomeArea = (BiomeArea)3,
					Group = "Wood_small",
					Priotized = true,
					RandomRotation = false,
					MinDistanceFromSimilar = 1024f,
					MaxTerrainDelta = 2f,
					MinAltitude = 1f,
					MinDistance = LocationRings.Ring5.MinDistance,
					InForest = true
				}
			},
			{
				"MWL_MeadowsRuin1_Config",
				new LocationConfig
				{
					Quantity = Meadows_Pack_2Plugin.MWL_MeadowsRuin1_Configuration.Quantity.Value,
					Biome = (Biome)1,
					BiomeArea = (BiomeArea)3,
					Group = "Ruins_small",
					Priotized = true,
					RandomRotation = false,
					MinDistanceFromSimilar = 1024f,
					MaxTerrainDelta = 2f,
					MinAltitude = 1f,
					MinDistance = LocationRings.Ring1.MinDistance,
					MaxDistance = LocationRings.Ring4.MaxDistance,
					InForest = false
				}
			},
			{
				"MWL_MeadowsTomb4_Config",
				new LocationConfig
				{
					Quantity = Meadows_Pack_2Plugin.MWL_MeadowsTomb4_Configuration.Quantity.Value,
					Biome = (Biome)1,
					BiomeArea = (BiomeArea)3,
					Group = "Environment_medium",
					Priotized = true,
					RandomRotation = false,
					MinDistanceFromSimilar = 512f,
					MaxTerrainDelta = 4f,
					MinAltitude = -1f,
					MaxAltitude = 1f,
					MinDistance = LocationRings.Ring2.MinDistance,
					MaxDistance = LocationRings.Ring4.MaxDistance,
					InForest = false
				}
			},
			{
				"MWL_MeadowsTower1_Config",
				new LocationConfig
				{
					Quantity = Meadows_Pack_2Plugin.MWL_MeadowsTower1_Configuration.Quantity.Value,
					Biome = (Biome)1,
					BiomeArea = (BiomeArea)3,
					Group = "Ruins_small",
					Priotized = true,
					RandomRotation = false,
					MinDistanceFromSimilar = 1024f,
					MaxTerrainDelta = 3f,
					MinAltitude = 1f,
					MinDistance = LocationRings.Ring2.MinDistance,
					MaxDistance = LocationRings.Ring5.MaxDistance,
					InForest = false
				}
			},
			{
				"MWL_OakHut1_Config",
				new LocationConfig
				{
					Quantity = Meadows_Pack_2Plugin.MWL_OakHut1_Configuration.Quantity.Value,
					Biome = (Biome)1,
					BiomeArea = (BiomeArea)3,
					Group = "Wood_small",
					Priotized = true,
					RandomRotation = false,
					MinDistanceFromSimilar = 1024f,
					MaxTerrainDelta = 2f,
					MinAltitude = 1f,
					MinDistance = LocationRings.Ring2.MinDistance,
					InForest = false
				}
			},
			{
				"MWL_SmallHouse1_Config",
				new LocationConfig
				{
					Quantity = Meadows_Pack_2Plugin.MWL_SmallHouse1_Configuration.Quantity.Value,
					Biome = (Biome)1,
					BiomeArea = (BiomeArea)3,
					Group = "Ruins_medium",
					Priotized = true,
					RandomRotation = false,
					MinDistanceFromSimilar = 1024f,
					MaxTerrainDelta = 3f,
					MinAltitude = 1f,
					MinDistance = LocationRings.Ring3.MinDistance,
					InForest = false
				}
			}
		};
	}
	public class Locations
	{
		public static void AddAllLocations()
		{
			AssetBundle assetBundle = Meadows_Pack_2Plugin.assetBundle;
			LocationManager.AddLocation(assetBundle, "MWL_DeerShrine1", Meadows_Pack_2Plugin.MWL_DeerShrine1_Configuration, LocationConfigs.AllLocationConfigs["MWL_DeerShrine1_Config"], Meadows_Pack_2Plugin.meadows2YAMLManager);
			LocationManager.AddLocation(assetBundle, "MWL_DeerShrine2", Meadows_Pack_2Plugin.MWL_DeerShrine2_Configuration, LocationConfigs.AllLocationConfigs["MWL_DeerShrine2_Config"], Meadows_Pack_2Plugin.meadows2YAMLManager);
			LocationManager.AddLocation(assetBundle, "MWL_MeadowsBarn1", Meadows_Pack_2Plugin.MWL_MeadowsBarn1_Configuration, LocationConfigs.AllLocationConfigs["MWL_MeadowsBarn1_Config"], Meadows_Pack_2Plugin.meadows2YAMLManager);
			LocationManager.AddLocation(assetBundle, "MWL_MeadowsHouse2", Meadows_Pack_2Plugin.MWL_MeadowsHouse2_Configuration, LocationConfigs.AllLocationConfigs["MWL_MeadowsHouse2_Config"], Meadows_Pack_2Plugin.meadows2YAMLManager);
			LocationManager.AddLocation(assetBundle, "MWL_MeadowsRuin1", Meadows_Pack_2Plugin.MWL_MeadowsRuin1_Configuration, LocationConfigs.AllLocationConfigs["MWL_MeadowsRuin1_Config"], Meadows_Pack_2Plugin.meadows2YAMLManager);
			LocationManager.AddLocation(assetBundle, "MWL_MeadowsTomb4", Meadows_Pack_2Plugin.MWL_MeadowsTomb4_Configuration, LocationConfigs.AllLocationConfigs["MWL_MeadowsTomb4_Config"], Meadows_Pack_2Plugin.meadows2YAMLManager);
			LocationManager.AddLocation(assetBundle, "MWL_MeadowsTower1", Meadows_Pack_2Plugin.MWL_MeadowsTower1_Configuration, LocationConfigs.AllLocationConfigs["MWL_MeadowsTower1_Config"], Meadows_Pack_2Plugin.meadows2YAMLManager);
			LocationManager.AddLocation(assetBundle, "MWL_OakHut1", Meadows_Pack_2Plugin.MWL_OakHut1_Configuration, LocationConfigs.AllLocationConfigs["MWL_OakHut1_Config"], Meadows_Pack_2Plugin.meadows2YAMLManager);
			LocationManager.AddLocation(assetBundle, "MWL_SmallHouse1", Meadows_Pack_2Plugin.MWL_SmallHouse1_Configuration, LocationConfigs.AllLocationConfigs["MWL_SmallHouse1_Config"], Meadows_Pack_2Plugin.meadows2YAMLManager);
		}
	}
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	[BepInPlugin("warpalicious.Meadows_Pack_2", "Meadows_Pack_2", "1.0.0")]
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	public class Meadows_Pack_2Plugin : BaseUnityPlugin
	{
		[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(0)]
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		internal const string ModName = "Meadows_Pack_2";

		internal const string ModVersion = "1.0.0";

		internal const string Author = "warpalicious";

		private const string ModGUID = "warpalicious.Meadows_Pack_2";

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

		private static string ConfigFileFullPath;

		internal static string ConnectionError;

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

		public static readonly ManualLogSource Meadows_Pack_2Logger;

		public Texture2D tex = null;

		public static YAMLManager meadows2YAMLManager;

		public static AssetBundle assetBundle;

		public static string bundleName;

		public static LocationConfiguration MWL_DeerShrine1_Configuration;

		public static LocationConfiguration MWL_DeerShrine2_Configuration;

		public static LocationConfiguration MWL_MeadowsBarn1_Configuration;

		public static LocationConfiguration MWL_MeadowsHouse2_Configuration;

		public static LocationConfiguration MWL_MeadowsRuin1_Configuration;

		public static LocationConfiguration MWL_MeadowsTomb4_Configuration;

		public static LocationConfiguration MWL_MeadowsTower1_Configuration;

		public static LocationConfiguration MWL_OakHut1_Configuration;

		public static LocationConfiguration MWL_SmallHouse1_Configuration;

		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();
			MWL_DeerShrine1_Configuration = new LocationConfiguration(((BaseUnityPlugin)this).Config, "MWL_DeerShrine1", 10, "MeadowsCreatures1", "MeadowsLoot1");
			MWL_DeerShrine2_Configuration = new LocationConfiguration(((BaseUnityPlugin)this).Config, "MWL_DeerShrine2", 10, "MeadowsCreatures1", "MeadowsLoot3");
			MWL_MeadowsBarn1_Configuration = new LocationConfiguration(((BaseUnityPlugin)this).Config, "MWL_MeadowsBarn1", 5, "MeadowsCreatures5", "MeadowsLoot1");
			MWL_MeadowsHouse2_Configuration = new LocationConfiguration(((BaseUnityPlugin)this).Config, "MWL_MeadowsHouse2", 20, "MeadowsCreatures2", "MeadowsLoot3");
			MWL_MeadowsRuin1_Configuration = new LocationConfiguration(((BaseUnityPlugin)this).Config, "MWL_MeadowsRuin1", 5, "MeadowsCreatures1", "MeadowsLoot1");
			MWL_MeadowsTomb4_Configuration = new LocationConfiguration(((BaseUnityPlugin)this).Config, "MWL_MeadowsTomb4", 10, "MeadowsCreatures1", "MeadowsLoot1");
			MWL_MeadowsTower1_Configuration = new LocationConfiguration(((BaseUnityPlugin)this).Config, "MWL_MeadowsTower1", 15, "MeadowsCreatures1", "MeadowsLoot1");
			MWL_OakHut1_Configuration = new LocationConfiguration(((BaseUnityPlugin)this).Config, "MWL_OakHut1", 15, "MeadowsCreatures1", "MeadowsLoot1");
			MWL_SmallHouse1_Configuration = new LocationConfiguration(((BaseUnityPlugin)this).Config, "MWL_SmallHouse1", 20, "MeadowsCreatures1", "MeadowsLoot1");
			meadows2YAMLManager.ParseDefaultYamls();
			meadows2YAMLManager.ParseCustomYamls();
			ZoneManager.OnVanillaLocationsAvailable += Locations.AddAllLocations;
			if (saveOnConfigSet)
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
				((BaseUnityPlugin)this).Config.Save();
			}
		}

		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
			{
				Meadows_Pack_2Logger.LogDebug((object)"ReadConfigValues called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				Meadows_Pack_2Logger.LogError((object)("There was an issue loading your " + ConfigFileName));
				Meadows_Pack_2Logger.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		static Meadows_Pack_2Plugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			Meadows_Pack_2Logger = Logger.CreateLogSource("Meadows_Pack_2");
			meadows2YAMLManager = new YAMLManager();
			bundleName = "meadowspack2";
		}
	}
	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);
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	public static class RegisterAndCheckVersion
	{
		[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>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
			Meadows_Pack_2Plugin.Meadows_Pack_2Logger.LogDebug((object)"Registering version RPC handler");
			peer.m_rpc.Register<ZPackage>("Meadows_Pack_2_VersionCheck", (Action<ZRpc, ZPackage>)RpcHandlers.RPC_Meadows_Pack_2_Version);
			Meadows_Pack_2Plugin.Meadows_Pack_2Logger.LogDebug((object)"Invoking version check");
			ZPackage val = new ZPackage();
			val.Write("1.0.0");
			peer.m_rpc.Invoke("Meadows_Pack_2_VersionCheck", new object[1] { val });
		}
	}
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	public static class VerifyClient
	{
		private static bool Prefix(ZRpc rpc, ZPackage pkg, ref ZNet __instance)
		{
			if (!__instance.IsServer() || RpcHandlers.ValidatedPeers.Contains(rpc))
			{
				return true;
			}
			Meadows_Pack_2Plugin.Meadows_Pack_2Logger.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(), "Meadows_Pack_2RequestAdminSync", new object[1] { (object)new ZPackage() });
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
	public class ShowConnectionError
	{
		[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>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" + Meadows_Pack_2Plugin.ConnectionError;
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Disconnect")]
	public static class RemoveDisconnectedPeerFromVerified
	{
		[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
		private static void Prefix(ZNetPeer peer, ref ZNet __instance)
		{
			if (__instance.IsServer())
			{
				Meadows_Pack_2Plugin.Meadows_Pack_2Logger.LogInfo((object)("Peer (" + peer.m_rpc.m_socket.GetHostName() + ") disconnected, removing from validated list"));
				RpcHandlers.ValidatedPeers.Remove(peer.m_rpc);
			}
		}
	}
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	public static class RpcHandlers
	{
		public static readonly List<ZRpc> ValidatedPeers = new List<ZRpc>();

		public static void RPC_Meadows_Pack_2_Version(ZRpc rpc, ZPackage pkg)
		{
			string text = pkg.ReadString();
			Meadows_Pack_2Plugin.Meadows_Pack_2Logger.LogInfo((object)("Version check, local: 1.0.0,  remote: " + text));
			if (text != "1.0.0")
			{
				Meadows_Pack_2Plugin.ConnectionError = "Meadows_Pack_2 Installed: 1.0.0\n Needed: " + text;
				if (ZNet.instance.IsServer())
				{
					Meadows_Pack_2Plugin.Meadows_Pack_2Logger.LogWarning((object)("Peer (" + rpc.m_socket.GetHostName() + ") has incompatible version, disconnecting..."));
					rpc.Invoke("Error", new object[1] { 3 });
				}
			}
			else if (!ZNet.instance.IsServer())
			{
				Meadows_Pack_2Plugin.Meadows_Pack_2Logger.LogInfo((object)"Received same version from server!");
			}
			else
			{
				Meadows_Pack_2Plugin.Meadows_Pack_2Logger.LogInfo((object)("Adding peer (" + rpc.m_socket.GetHostName() + ") to validated list"));
				ValidatedPeers.Add(rpc);
			}
		}
	}
}
namespace LocalizationManager
{
	[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(1)]
	[PublicAPI]
	[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(0)]
	public class Localizer
	{
		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

		private static readonly Dictionary<string, Dictionary<string, string>> loadedTexts;

		private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;

		private static readonly List<WeakReference<Localization>> localizationObjects;

		[<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static readonly List<string> fileExtensions;

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First([<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		private static void UpdatePlaceholderText(Localization localization, string key)
		{
			localizationLanguage.TryGetValue(localization, out var value);
			string text = loadedTexts[value][key];
			if (PlaceholderProcessors.TryGetValue(key, out var value2))
			{
				text = value2.Aggregate(text, [<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(0)] (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
			}
			localization.AddWord(key, text);
		}

		public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, [<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(new byte[] { 2, 1, 1 })] Func<T, string> convertConfigValue = null)
		{
			if (convertConfigValue == null)
			{
				convertConfigValue = (T val) => val.ToString();
			}
			if (!PlaceholderProcessors.ContainsKey(key))
			{
				PlaceholderProcessors[key] = new Dictionary<string, Func<string>>();
			}
			config.SettingChanged += [<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(0)] (object _, EventArgs _) =>
			{
				UpdatePlaceholder();
			};
			if (loadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
			{
				UpdatePlaceholder();
			}
			void UpdatePlaceholder()
			{
				PlaceholderProcessors[key][placeholder] = () => convertConfigValue(config.Value);
				UpdatePlaceholderText(Localization.instance, key);
			}
		}

		public static void AddText(string key, string text)
		{
			List<WeakReference<Localization>> list = new List<WeakReference<Localization>>();
			foreach (WeakReference<Localization> localizationObject in localizationObjects)
			{
				if (localizationObject.TryGetTarget(out var target))
				{
					Dictionary<string, string> dictionary = loadedTexts[localizationLanguage.GetOrCreateValue(target)];
					if (!target.m_translations.ContainsKey(key))
					{
						dictionary[key] = text;
						target.AddWord(key, text);
					}
				}
				else
				{
					list.Add(localizationObject);
				}
			}
			foreach (WeakReference<Localization> item in list)
			{
				localizationObjects.Remove(item);
			}
		}

		public static void Load()
		{
			LoadLocalization(Localization.instance, Localization.instance.GetSelectedLanguage());
		}

		private static void LoadLocalization(Localization __instance, string language)
		{
			if (!localizationLanguage.Remove(__instance))
			{
				localizationObjects.Add(new WeakReference<Localization>(__instance));
			}
			localizationLanguage.Add(__instance, language);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (string item in from f in Directory.GetFiles(Path.GetDirectoryName(Paths.PluginPath), plugin.Info.Metadata.Name + ".*", SearchOption.AllDirectories)
				where fileExtensions.IndexOf(Path.GetExtension(f)) >= 0
				select f)
			{
				string text = Path.GetFileNameWithoutExtension(item).Split(new char[1] { '.' })[1];
				if (dictionary.ContainsKey(text))
				{
					Debug.LogWarning((object)("Duplicate key " + text + " found for " + plugin.Info.Metadata.Name + ". The duplicate file found at " + item + " will be skipped."));
				}
				else
				{
					dictionary[text] = item;
				}
			}
			byte[] array = LoadTranslationFromAssembly("English");
			if (array == null)
			{
				throw new Exception("Found no English localizations in mod " + plugin.Info.Metadata.Name + ". Expected an embedded resource translations/English.json or translations/English.yml.");
			}
			Dictionary<string, string> dictionary2 = new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array));
			if (dictionary2 == null)
			{
				throw new Exception("Localization for mod " + plugin.Info.Metadata.Name + " failed: Localization file was empty.");
			}
			string text2 = null;
			if (language != "English")
			{
				if (dictionary.ContainsKey(language))
				{
					text2 = File.ReadAllText(dictionary[language]);
				}
				else
				{
					byte[] array2 = LoadTranslationFromAssembly(language);
					if (array2 != null)
					{
						text2 = Encoding.UTF8.GetString(array2);
					}
				}
			}
			if (text2 == null && dictionary.ContainsKey("English"))
			{
				text2 = File.ReadAllText(dictionary["English"]);
			}
			if (text2 != null)
			{
				foreach (KeyValuePair<string, string> item2 in new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text2) ?? new Dictionary<string, string>())
				{
					dictionary2[item2.Key] = item2.Value;
				}
			}
			loadedTexts[language] = dictionary2;
			foreach (KeyValuePair<string, string> item3 in dictionary2)
			{
				UpdatePlaceholderText(__instance, item3.Key);
			}
		}

		static Localizer()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
			loadedTexts = new Dictionary<string, Dictionary<string, string>>();
			localizationLanguage = new ConditionalWeakTable<Localization, string>();
			localizationObjects = new List<WeakReference<Localization>>();
			fileExtensions = new List<string> { ".json", ".yml" };
			Harmony val = new Harmony("org.bepinex.helpers.LocalizationManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		[return: <b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(2)]
		private static byte[] LoadTranslationFromAssembly(string language)
		{
			foreach (string fileExtension in fileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
				if (array != null)
				{
					return array;
				}
			}
			return null;
		}

		[<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(2)]
		public static byte[] ReadEmbeddedFileBytes([<b642bea3-0317-4081-beee-8d1bf9cc2c0d>Nullable(1)] string resourceFileName, Assembly containingAssembly = null)
		{
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault([<08290e31-9252-4cfd-ad9a-c56cb535f0e3>NullableContext(0)] (string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
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.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

		public TBuilder WithoutTypeInspector(Type inspectorType)
		{
			if (inspectorType == null)
			{
				throw new ArgumentNullException("inspectorType");
			}
			typeInspectorFactories.Remove(inspectorType);
			return Self;
		}

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	internal sealed class Deserializer : IDeserializer
	{
		private readonly IValueDeserializer valueDeserializer;

		public Deserializer()
			: this(new DeserializerBuilder().BuildValueDeserializer())
		{
		}

		private Deserializer(IValueDeserializer valueDeserializer)
		{
			this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
		}

		public static Deserializer FromValueDeserializer(IValueDeserializer valueDeserializer)
		{
			return new Deserializer(valueDeserializer);
		}

		public T Deserialize<T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		public T Deserialize<T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		public object? Deserialize(string input)
		{
			return Deserialize(input, typeof(object));
		}

		public object? Deserialize(TextReader input)
		{
			return Deserialize(input, typeof(object));
		}

		public object? Deserialize(IParser parser)
		{
			return Deserialize(parser, typeof(object));
		}

		public object? Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		public object? Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		public object? Deserialize(IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			YamlDotNet.Core.Events.StreamStart @event;
			bool flag = parser.TryConsume<YamlDotNet.Core.Events.StreamStart>(out @event);
			YamlDotNet.Core.Events.DocumentStart event2;
			bool flag2 = parser.TryConsume<YamlDotNet.Core.Events.DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<YamlDotNet.Core.Events.DocumentEnd>(out var _) && !parser.Accept<YamlDotNet.Core.Events.StreamEnd>(out var _))
			{
				using SerializerState serializerState = new SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
				serializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<YamlDotNet.Core.Events.DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<YamlDotNet.Core.Events.StreamEnd>();
			}
			return result;
		}
	}
	internal sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
	{
		private Lazy<IObjectFactory> objectFactory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private readonly ITypeConverter typeConverter;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		protected override DeserializerBuilder Self => this;

		public DeserializerBuilder()
			: base((ITypeResolver)new StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<IObjectFactory>(() => new DefaultObjectFactory(typeMappings, settings), isThreadSafe: true);
			tagMappings = new Dictionary<TagName, Type>
			{
				{
					FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(YamlAttributeOverridesInspector), (ITypeInspector inner) => (overrides == null) ? inner : new YamlAttributeOverridesInspector(inner, overrides.Clone()));
			typeInspectorFactories.Add(typeof(ReadableAndWritablePropertiesTypeInspector), (ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner));
			nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
			{
				{
					typeof(YamlConvertibleNodeDeserializer),
					(Nothing _) => new YamlConvertibleNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(YamlSerializableNodeDeserializer),
					(Nothing _) => new YamlSerializableNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(TypeConverterNodeDeserializer),
					(Nothing _) => new TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(NullNodeDeserializer),
					(Nothing _) => new NullNodeDeserializer()
				},
				{
					typeof(ScalarNodeDeserializer),
					(Nothing _) => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter)
				},
				{
					typeof(ArrayNodeDeserializer),
					(Nothing _) => new ArrayNodeDeserializer()
				},
				{
					typeof(DictionaryNodeDeserializer),
					(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
				},
				{
					typeof(CollectionNodeDeserializer),
					(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(EnumerableNodeDeserializer),
					(Nothing _) => new EnumerableNodeDeserializer()
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter)
				}
			};
			nodeTypeResolverFactories = new LazyComponentRegistrationList<Nothing, INodeTypeResolver>
			{
				{
					typeof(MappingNodeTypeResolver),
					(Nothing _) => new MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(YamlConvertibleTypeResolver),
					(Nothing _) => new YamlConvertibleTypeResolver()
				},
				{
					typeof(YamlSerializableTypeResolver),
					(Nothing _) => new YamlSerializableTypeResolver()
				},
				{
					typeof(TagNodeTypeResolver),
					(Nothing _) => new TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(PreventUnknownTagsNodeTypeResolver),
					(Nothing _) => new PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(DefaultContainersNodeTypeResolver),
					(Nothing _) => new DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new ReflectionTypeConverter();
		}

		internal ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new WritablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

		public DeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
		{
			IObjectFactory objectFactory2 = objectFactory;
			if (objectFactory2 == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory2, isThreadSafe: true);
			return this;
		}

		public DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new LambdaObjectFactory(objectFactory));
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
		{
			INodeDeserializer nodeDeserializer2 = nodeDeserializer;
			if (nodeDeserializer2 == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
			return this;
		}

		public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerF