using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Extensions;
using Jotunn.GUI;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using SimpleJson;
using SimpleJson.Reflection;
using SoftReferenceableAssets;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.SceneManagement;
using UnityEngine.U2D;
using UnityEngine.UI;
using YamlDotNet.Serialization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("JotunnTests")]
[assembly: InternalsVisibleTo("JotunnDoc")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyCompany("Valheim-Modding team")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Jötunn (/ˈjɔːtʊn/, \"giant\") is a modding library for Valheim, with the goal of making the lives of mod developers easier.")]
[assembly: AssemblyFileVersion("2.29.1.0")]
[assembly: AssemblyInformationalVersion("2.29.1+ea3b5ce75055888526cf07a8897ba6bbceac4772")]
[assembly: AssemblyProduct("JotunnLib")]
[assembly: AssemblyTitle("Jotunn")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Valheim-Modding/Jotunn")]
[assembly: NeutralResourcesLanguage("en")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.29.1.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
internal class CompatibilityWindow : MonoBehaviour
{
	public ScrollRect scrollRect;

	public Text failedConnection;

	public Text localVersion;

	public Text remoteVersion;

	public Text errorMessages;

	public Button continueButton;

	public Button logFileButton;

	public Button troubleshootingButton;

	public void UpdateTextPositions()
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Expected O, but got Unknown
		float preferredHeight = failedConnection.preferredHeight;
		float preferredHeight2 = localVersion.preferredHeight;
		float preferredHeight3 = remoteVersion.preferredHeight;
		float preferredHeight4 = errorMessages.preferredHeight;
		Vector2 anchoredPosition = ((Graphic)localVersion).rectTransform.anchoredPosition;
		Vector2 anchoredPosition2 = ((Graphic)remoteVersion).rectTransform.anchoredPosition;
		float num = preferredHeight + 32f;
		((Graphic)localVersion).rectTransform.anchoredPosition = new Vector2(anchoredPosition.x, 0f - num);
		((Graphic)remoteVersion).rectTransform.anchoredPosition = new Vector2(anchoredPosition2.x, 0f - num);
		Vector2 anchoredPosition3 = ((Graphic)errorMessages).rectTransform.anchoredPosition;
		float num2 = num + Mathf.Max(preferredHeight2, preferredHeight3) + 32f;
		((Graphic)errorMessages).rectTransform.anchoredPosition = new Vector2(anchoredPosition3.x, 0f - num2);
		RectTransform val = (RectTransform)((Component)scrollRect.content).transform;
		val.SetSizeWithCurrentAnchors((Axis)1, num2 + preferredHeight4);
	}
}
public sealed class ConfigurationManagerAttributes
{
	public bool? ShowRangeAsPercent;

	public Action<ConfigEntryBase> CustomDrawer;

	public bool? Browsable;

	public string Category;

	public object DefaultValue;

	public bool? HideDefaultButton;

	public bool? HideSettingName;

	public string Description;

	public string DispName;

	public int? Order;

	public bool? ReadOnly;

	public bool? IsAdvanced;

	public Func<object, string> ObjToStr;

	public Func<string, object> StrToObj;

	private bool isAdminOnly;

	private bool isUnlocked = true;

	private static readonly PropertyInfo[] _myProperties = typeof(ConfigurationManagerAttributes).GetProperties(BindingFlags.Instance | BindingFlags.Public);

	private static readonly FieldInfo[] _myFields = typeof(ConfigurationManagerAttributes).GetFields(BindingFlags.Instance | BindingFlags.Public);

	public bool IsAdminOnly
	{
		get
		{
			return isAdminOnly;
		}
		set
		{
			isAdminOnly = value;
			bool flag = isAdminOnly && !SynchronizationManager.Instance.PlayerIsAdmin;
			IsUnlocked = !flag;
		}
	}

	public Color EntryColor { get; set; }

	public Color DescriptionColor { get; set; }

	public bool IsUnlocked
	{
		get
		{
			return isUnlocked;
		}
		internal set
		{
			ReadOnly = !value;
			HideDefaultButton = !value;
			isUnlocked = value;
		}
	}

	public ConfigurationManagerAttributes()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		EntryColor = new Color(1f, 0.631f, 0.235f, 1f);
		DescriptionColor = Color.white;
	}

	public void SetFromAttributes(object[] attribs)
	{
		if (attribs == null || attribs.Length == 0)
		{
			return;
		}
		foreach (object obj in attribs)
		{
			if (obj == null)
			{
				continue;
			}
			if (!(obj is DisplayNameAttribute displayNameAttribute))
			{
				if (!(obj is CategoryAttribute categoryAttribute))
				{
					if (!(obj is DescriptionAttribute descriptionAttribute))
					{
						if (!(obj is DefaultValueAttribute defaultValueAttribute))
						{
							if (!(obj is ReadOnlyAttribute readOnlyAttribute))
							{
								if (!(obj is BrowsableAttribute browsableAttribute))
								{
									if (obj is string text)
									{
										switch (text)
										{
										case "ReadOnly":
											ReadOnly = true;
											break;
										case "Browsable":
											Browsable = true;
											break;
										case "Unbrowsable":
										case "Hidden":
											Browsable = false;
											break;
										case "Advanced":
											IsAdvanced = true;
											break;
										}
										continue;
									}
									Type type = obj.GetType();
									if (!(type.Name == "ConfigurationManagerAttributes"))
									{
										break;
									}
									FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
									foreach (var item in from my in _myProperties
										join other in fields on my.Name equals other.Name
										select new { my, other })
									{
										try
										{
											object obj2 = item.other.GetValue(obj);
											if (obj2 != null)
											{
												if (item.my.PropertyType != item.other.FieldType && typeof(Delegate).IsAssignableFrom(item.my.PropertyType))
												{
													obj2 = Delegate.CreateDelegate(item.my.PropertyType, ((Delegate)obj2).Target, ((Delegate)obj2).Method);
												}
												item.my.SetValue(this, obj2, null);
											}
										}
										catch (Exception ex)
										{
											Logger.LogWarning("Failed to copy value " + item.my.Name + " from provided tag object " + type.FullName + " - " + ex.Message);
										}
									}
									foreach (var item2 in from my in _myFields
										join other in fields on my.Name equals other.Name
										select new { my, other })
									{
										try
										{
											object obj3 = item2.other.GetValue(obj);
											if (obj3 != null)
											{
												if (item2.my.FieldType != item2.other.FieldType && typeof(Delegate).IsAssignableFrom(item2.my.FieldType))
												{
													obj3 = Delegate.CreateDelegate(item2.my.FieldType, ((Delegate)obj3).Target, ((Delegate)obj3).Method);
												}
												item2.my.SetValue(this, obj3);
											}
										}
										catch (Exception ex2)
										{
											Logger.LogWarning("Failed to copy value " + item2.my.Name + " from provided tag object " + type.FullName + " - " + ex2.Message);
										}
									}
								}
								else
								{
									Browsable = browsableAttribute.Browsable;
								}
							}
							else
							{
								ReadOnly = readOnlyAttribute.IsReadOnly;
							}
						}
						else
						{
							DefaultValue = defaultValueAttribute.Value;
						}
					}
					else
					{
						Description = descriptionAttribute.Description;
					}
				}
				else
				{
					Category = categoryAttribute.Category;
				}
			}
			else
			{
				DispName = displayNameAttribute.DisplayName;
			}
		}
	}
}
public static class ObjImporter
{
	private struct meshStruct
	{
		public Vector3[] vertices;

		public Vector3[] normals;

		public Vector2[] uv;

		public Vector2[] uv1;

		public Vector2[] uv2;

		public int[] triangles;

		public int[] faceVerts;

		public int[] faceUVs;

		public Vector3[] faceData;

		public string name;

		public string fileName;
	}

	public static Mesh ImportFile(string filePath)
	{
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Expected O, but got Unknown
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		meshStruct mesh = CreateMeshStruct(filePath);
		PopulateMeshStruct(ref mesh);
		Vector3[] array = (Vector3[])(object)new Vector3[mesh.faceData.Length];
		Vector2[] array2 = (Vector2[])(object)new Vector2[mesh.faceData.Length];
		Vector3[] array3 = (Vector3[])(object)new Vector3[mesh.faceData.Length];
		int num = 0;
		Vector3[] faceData = mesh.faceData;
		foreach (Vector3 val in faceData)
		{
			array[num] = mesh.vertices[(int)val.x - 1];
			if (val.y >= 1f)
			{
				array2[num] = mesh.uv[(int)val.y - 1];
			}
			if (val.z >= 1f)
			{
				array3[num] = mesh.normals[(int)val.z - 1];
			}
			num++;
		}
		Mesh val2 = new Mesh();
		val2.vertices = array;
		val2.uv = array2;
		val2.normals = array3;
		val2.triangles = mesh.triangles;
		val2.RecalculateBounds();
		val2.Optimize();
		return val2;
	}

	private static meshStruct CreateMeshStruct(string filename)
	{
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		int num5 = 0;
		meshStruct result = new meshStruct
		{
			fileName = filename
		};
		StreamReader streamReader = File.OpenText(filename);
		string s = streamReader.ReadToEnd();
		streamReader.Close();
		using (StringReader stringReader = new StringReader(s))
		{
			string text = stringReader.ReadLine();
			char[] separator = new char[1] { ' ' };
			while (text != null)
			{
				if (!text.StartsWith("f ") && !text.StartsWith("v ") && !text.StartsWith("vt ") && !text.StartsWith("vn "))
				{
					text = stringReader.ReadLine();
					if (text != null)
					{
						text = text.Replace("  ", " ");
					}
					continue;
				}
				text = text.Trim();
				string[] array = text.Split(separator, 50);
				switch (array[0])
				{
				case "v":
					num2++;
					break;
				case "vt":
					num3++;
					break;
				case "vn":
					num4++;
					break;
				case "f":
					num5 = num5 + array.Length - 1;
					num += 3 * (array.Length - 2);
					break;
				}
				text = stringReader.ReadLine();
				if (text != null)
				{
					text = text.Replace("  ", " ");
				}
			}
		}
		result.triangles = new int[num];
		result.vertices = (Vector3[])(object)new Vector3[num2];
		result.uv = (Vector2[])(object)new Vector2[num3];
		result.normals = (Vector3[])(object)new Vector3[num4];
		result.faceData = (Vector3[])(object)new Vector3[num5];
		return result;
	}

	private static void PopulateMeshStruct(ref meshStruct mesh)
	{
		//IL_0329: Unknown result type (might be due to invalid IL or missing references)
		//IL_032e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0390: Unknown result type (might be due to invalid IL or missing references)
		//IL_0395: Unknown result type (might be due to invalid IL or missing references)
		//IL_0358: Unknown result type (might be due to invalid IL or missing references)
		//IL_035d: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0423: Unknown result type (might be due to invalid IL or missing references)
		//IL_0425: Unknown result type (might be due to invalid IL or missing references)
		StreamReader streamReader = File.OpenText(mesh.fileName);
		string s = streamReader.ReadToEnd();
		streamReader.Close();
		using StringReader stringReader = new StringReader(s);
		string text = stringReader.ReadLine();
		char[] separator = new char[1] { ' ' };
		char[] separator2 = new char[1] { '/' };
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		int num5 = 0;
		int num6 = 0;
		int num7 = 0;
		while (text != null)
		{
			if (!text.StartsWith("f ") && !text.StartsWith("v ") && !text.StartsWith("vt ") && !text.StartsWith("vn ") && !text.StartsWith("g ") && !text.StartsWith("usemtl ") && !text.StartsWith("mtllib ") && !text.StartsWith("vt1 ") && !text.StartsWith("vt2 ") && !text.StartsWith("vc ") && !text.StartsWith("usemap "))
			{
				text = stringReader.ReadLine();
				if (text != null)
				{
					text = text.Replace("  ", " ");
				}
				continue;
			}
			text = text.Trim();
			string[] array = text.Split(separator, 50);
			switch (array[0])
			{
			case "v":
				mesh.vertices[num3] = new Vector3(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]), Convert.ToSingle(array[3]));
				num3++;
				break;
			case "vt":
				mesh.uv[num5] = new Vector2(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]));
				num5++;
				break;
			case "vt1":
				mesh.uv[num6] = new Vector2(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]));
				num6++;
				break;
			case "vt2":
				mesh.uv[num7] = new Vector2(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]));
				num7++;
				break;
			case "vn":
				mesh.normals[num4] = new Vector3(Convert.ToSingle(array[1]), Convert.ToSingle(array[2]), Convert.ToSingle(array[3]));
				num4++;
				break;
			case "f":
			{
				int num8 = 1;
				List<int> list = new List<int>();
				while (num8 < array.Length && (array[num8] ?? "").Length > 0)
				{
					Vector3 val = default(Vector3);
					string[] array2 = array[num8].Split(separator2, 3);
					val.x = Convert.ToInt32(array2[0]);
					if (array2.Length > 1)
					{
						if (array2[1] != "")
						{
							val.y = Convert.ToInt32(array2[1]);
						}
						val.z = Convert.ToInt32(array2[2]);
					}
					num8++;
					mesh.faceData[num2] = val;
					list.Add(num2);
					num2++;
				}
				for (num8 = 1; num8 + 2 < array.Length; num8++)
				{
					mesh.triangles[num] = list[0];
					num++;
					mesh.triangles[num] = list[num8];
					num++;
					mesh.triangles[num] = list[num8 + 1];
					num++;
				}
				break;
			}
			}
			text = stringReader.ReadLine();
			if (text != null)
			{
				text = text.Replace("  ", " ");
			}
		}
	}
}
namespace SimpleJson
{
	[GeneratedCode("simple-json", "1.0.0")]
	[EditorBrowsable(EditorBrowsableState.Never)]
	public class JsonArray : List<object>
	{
		public JsonArray()
		{
		}

		public JsonArray(int capacity)
			: base(capacity)
		{
		}

		public override string ToString()
		{
			return SimpleJson.SerializeObject(this) ?? string.Empty;
		}
	}
	[GeneratedCode("simple-json", "1.0.0")]
	[EditorBrowsable(EditorBrowsableState.Never)]
	public class JsonObject : IDictionary<string, object>, ICollection<KeyValuePair<string, object>>, IEnumerable<KeyValuePair<string, object>>, IEnumerable
	{
		private readonly Dictionary<string, object> _members;

		public object this[int index] => GetAtIndex(_members, index);

		public ICollection<string> Keys => _members.Keys;

		public ICollection<object> Values => _members.Values;

		public object this[string key]
		{
			get
			{
				return _members[key];
			}
			set
			{
				_members[key] = value;
			}
		}

		public int Count => _members.Count;

		public bool IsReadOnly => false;

		public JsonObject()
		{
			_members = new Dictionary<string, object>();
		}

		public JsonObject(IEqualityComparer<string> comparer)
		{
			_members = new Dictionary<string, object>(comparer);
		}

		internal static object GetAtIndex(IDictionary<string, object> obj, int index)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			if (index >= obj.Count)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			int num = 0;
			foreach (KeyValuePair<string, object> item in obj)
			{
				if (num++ == index)
				{
					return item.Value;
				}
			}
			return null;
		}

		public void Add(string key, object value)
		{
			_members.Add(key, value);
		}

		public bool ContainsKey(string key)
		{
			return _members.ContainsKey(key);
		}

		public bool Remove(string key)
		{
			return _members.Remove(key);
		}

		public bool TryGetValue(string key, out object value)
		{
			return _members.TryGetValue(key, out value);
		}

		public void Add(KeyValuePair<string, object> item)
		{
			_members.Add(item.Key, item.Value);
		}

		public void Clear()
		{
			_members.Clear();
		}

		public bool Contains(KeyValuePair<string, object> item)
		{
			if (_members.ContainsKey(item.Key))
			{
				return _members[item.Key] == item.Value;
			}
			return false;
		}

		public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			int num = Count;
			using IEnumerator<KeyValuePair<string, object>> enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<string, object> current = enumerator.Current;
				array[arrayIndex++] = current;
				if (--num <= 0)
				{
					break;
				}
			}
		}

		public bool Remove(KeyValuePair<string, object> item)
		{
			return _members.Remove(item.Key);
		}

		public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
		{
			return _members.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return _members.GetEnumerator();
		}

		public override string ToString()
		{
			return SimpleJson.SerializeObject(this);
		}
	}
	[GeneratedCode("simple-json", "1.0.0")]
	public static class SimpleJson
	{
		private const int TOKEN_NONE = 0;

		private const int TOKEN_CURLY_OPEN = 1;

		private const int TOKEN_CURLY_CLOSE = 2;

		private const int TOKEN_SQUARED_OPEN = 3;

		private const int TOKEN_SQUARED_CLOSE = 4;

		private const int TOKEN_COLON = 5;

		private const int TOKEN_COMMA = 6;

		private const int TOKEN_STRING = 7;

		private const int TOKEN_NUMBER = 8;

		private const int TOKEN_TRUE = 9;

		private const int TOKEN_FALSE = 10;

		private const int TOKEN_NULL = 11;

		private const int BUILDER_CAPACITY = 2000;

		private static readonly char[] EscapeTable;

		private static readonly char[] EscapeCharacters;

		private static readonly string EscapeCharactersString;

		private static IJsonSerializerStrategy _currentJsonSerializerStrategy;

		private static PocoJsonSerializerStrategy _pocoJsonSerializerStrategy;

		public static IJsonSerializerStrategy CurrentJsonSerializerStrategy
		{
			get
			{
				return _currentJsonSerializerStrategy ?? (_currentJsonSerializerStrategy = PocoJsonSerializerStrategy);
			}
			set
			{
				_currentJsonSerializerStrategy = value;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public static PocoJsonSerializerStrategy PocoJsonSerializerStrategy => _pocoJsonSerializerStrategy ?? (_pocoJsonSerializerStrategy = new PocoJsonSerializerStrategy());

		static SimpleJson()
		{
			EscapeCharacters = new char[7] { '"', '\\', '\b', '\f', '\n', '\r', '\t' };
			EscapeCharactersString = new string(EscapeCharacters);
			EscapeTable = new char[93];
			EscapeTable[34] = '"';
			EscapeTable[92] = '\\';
			EscapeTable[8] = 'b';
			EscapeTable[12] = 'f';
			EscapeTable[10] = 'n';
			EscapeTable[13] = 'r';
			EscapeTable[9] = 't';
		}

		public static object DeserializeObject(string json)
		{
			if (TryDeserializeObject(json, out var obj))
			{
				return obj;
			}
			throw new SerializationException("Invalid JSON string");
		}

		public static bool TryDeserializeObject(string json, out object obj)
		{
			bool success = true;
			if (json != null)
			{
				char[] json2 = json.ToCharArray();
				int index = 0;
				obj = ParseValue(json2, ref index, ref success);
			}
			else
			{
				obj = null;
			}
			return success;
		}

		public static object DeserializeObject(string json, Type type, IJsonSerializerStrategy jsonSerializerStrategy)
		{
			object obj = DeserializeObject(json);
			if (!(type == null) && (obj == null || !ReflectionUtils.IsAssignableFrom(obj.GetType(), type)))
			{
				return (jsonSerializerStrategy ?? CurrentJsonSerializerStrategy).DeserializeObject(obj, type);
			}
			return obj;
		}

		public static object DeserializeObject(string json, Type type)
		{
			return DeserializeObject(json, type, null);
		}

		public static T DeserializeObject<T>(string json, IJsonSerializerStrategy jsonSerializerStrategy)
		{
			return (T)DeserializeObject(json, typeof(T), jsonSerializerStrategy);
		}

		public static T DeserializeObject<T>(string json)
		{
			return (T)DeserializeObject(json, typeof(T), null);
		}

		public static string SerializeObject(object json, IJsonSerializerStrategy jsonSerializerStrategy)
		{
			StringBuilder stringBuilder = new StringBuilder(2000);
			if (!SerializeValue(jsonSerializerStrategy, json, stringBuilder))
			{
				return null;
			}
			return stringBuilder.ToString();
		}

		public static string SerializeObject(object json)
		{
			return SerializeObject(json, CurrentJsonSerializerStrategy);
		}

		public static string EscapeToJavascriptString(string jsonString)
		{
			if (string.IsNullOrEmpty(jsonString))
			{
				return jsonString;
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			while (num < jsonString.Length)
			{
				char c = jsonString[num++];
				if (c == '\\')
				{
					int num2 = jsonString.Length - num;
					if (num2 >= 2)
					{
						switch (jsonString[num])
						{
						case '\\':
							stringBuilder.Append('\\');
							num++;
							break;
						case '"':
							stringBuilder.Append("\"");
							num++;
							break;
						case 't':
							stringBuilder.Append('\t');
							num++;
							break;
						case 'b':
							stringBuilder.Append('\b');
							num++;
							break;
						case 'n':
							stringBuilder.Append('\n');
							num++;
							break;
						case 'r':
							stringBuilder.Append('\r');
							num++;
							break;
						}
					}
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		private static IDictionary<string, object> ParseObject(char[] json, ref int index, ref bool success)
		{
			IDictionary<string, object> dictionary = new JsonObject();
			NextToken(json, ref index);
			bool flag = false;
			while (!flag)
			{
				switch (LookAhead(json, index))
				{
				case 0:
					success = false;
					return null;
				case 6:
					NextToken(json, ref index);
					continue;
				case 2:
					NextToken(json, ref index);
					return dictionary;
				}
				string key = ParseString(json, ref index, ref success);
				if (!success)
				{
					success = false;
					return null;
				}
				int num = NextToken(json, ref index);
				if (num != 5)
				{
					success = false;
					return null;
				}
				object value = ParseValue(json, ref index, ref success);
				if (!success)
				{
					success = false;
					return null;
				}
				dictionary[key] = value;
			}
			return dictionary;
		}

		private static JsonArray ParseArray(char[] json, ref int index, ref bool success)
		{
			JsonArray jsonArray = new JsonArray();
			NextToken(json, ref index);
			bool flag = false;
			while (!flag)
			{
				switch (LookAhead(json, index))
				{
				case 0:
					success = false;
					return null;
				case 6:
					NextToken(json, ref index);
					continue;
				case 4:
					break;
				default:
				{
					object item = ParseValue(json, ref index, ref success);
					if (!success)
					{
						return null;
					}
					jsonArray.Add(item);
					continue;
				}
				}
				NextToken(json, ref index);
				break;
			}
			return jsonArray;
		}

		private static object ParseValue(char[] json, ref int index, ref bool success)
		{
			switch (LookAhead(json, index))
			{
			case 7:
				return ParseString(json, ref index, ref success);
			case 8:
				return ParseNumber(json, ref index, ref success);
			case 1:
				return ParseObject(json, ref index, ref success);
			case 3:
				return ParseArray(json, ref index, ref success);
			case 9:
				NextToken(json, ref index);
				return true;
			case 10:
				NextToken(json, ref index);
				return false;
			case 11:
				NextToken(json, ref index);
				return null;
			default:
				success = false;
				return null;
			}
		}

		private static string ParseString(char[] json, ref int index, ref bool success)
		{
			StringBuilder stringBuilder = new StringBuilder(2000);
			EatWhitespace(json, ref index);
			char c = json[index++];
			bool flag = false;
			while (!flag && index != json.Length)
			{
				c = json[index++];
				switch (c)
				{
				case '"':
					flag = true;
					break;
				case '\\':
				{
					if (index == json.Length)
					{
						break;
					}
					switch (json[index++])
					{
					case '"':
						stringBuilder.Append('"');
						continue;
					case '\\':
						stringBuilder.Append('\\');
						continue;
					case '/':
						stringBuilder.Append('/');
						continue;
					case 'b':
						stringBuilder.Append('\b');
						continue;
					case 'f':
						stringBuilder.Append('\f');
						continue;
					case 'n':
						stringBuilder.Append('\n');
						continue;
					case 'r':
						stringBuilder.Append('\r');
						continue;
					case 't':
						stringBuilder.Append('\t');
						continue;
					case 'u':
						break;
					default:
						continue;
					}
					int num = json.Length - index;
					if (num < 4)
					{
						break;
					}
					if (!(success = uint.TryParse(new string(json, index, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result)))
					{
						return "";
					}
					if (55296 <= result && result <= 56319)
					{
						index += 4;
						num = json.Length - index;
						if (num < 6 || !(new string(json, index, 2) == "\\u") || !uint.TryParse(new string(json, index + 2, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result2) || 56320 > result2 || result2 > 57343)
						{
							success = false;
							return "";
						}
						stringBuilder.Append((char)result);
						stringBuilder.Append((char)result2);
						index += 6;
					}
					else
					{
						stringBuilder.Append(ConvertFromUtf32((int)result));
						index += 4;
					}
					continue;
				}
				default:
					stringBuilder.Append(c);
					continue;
				}
				break;
			}
			if (!flag)
			{
				success = false;
				return null;
			}
			return stringBuilder.ToString();
		}

		private static string ConvertFromUtf32(int utf32)
		{
			if (utf32 < 0 || utf32 > 1114111)
			{
				throw new ArgumentOutOfRangeException("utf32", "The argument must be from 0 to 0x10FFFF.");
			}
			if (55296 <= utf32 && utf32 <= 57343)
			{
				throw new ArgumentOutOfRangeException("utf32", "The argument must not be in surrogate pair range.");
			}
			if (utf32 < 65536)
			{
				return new string((char)utf32, 1);
			}
			utf32 -= 65536;
			return new string(new char[2]
			{
				(char)((utf32 >> 10) + 55296),
				(char)(utf32 % 1024 + 56320)
			});
		}

		private static object ParseNumber(char[] json, ref int index, ref bool success)
		{
			EatWhitespace(json, ref index);
			int lastIndexOfNumber = GetLastIndexOfNumber(json, index);
			int length = lastIndexOfNumber - index + 1;
			string text = new string(json, index, length);
			object result2;
			if (text.IndexOf(".", StringComparison.OrdinalIgnoreCase) != -1 || text.IndexOf("e", StringComparison.OrdinalIgnoreCase) != -1)
			{
				success = double.TryParse(new string(json, index, length), NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
				result2 = result;
			}
			else
			{
				success = long.TryParse(new string(json, index, length), NumberStyles.Any, CultureInfo.InvariantCulture, out var result3);
				result2 = result3;
			}
			index = lastIndexOfNumber + 1;
			return result2;
		}

		private static int GetLastIndexOfNumber(char[] json, int index)
		{
			int i;
			for (i = index; i < json.Length && "0123456789+-.eE".IndexOf(json[i]) != -1; i++)
			{
			}
			return i - 1;
		}

		private static void EatWhitespace(char[] json, ref int index)
		{
			while (index < json.Length && " \t\n\r\b\f".IndexOf(json[index]) != -1)
			{
				index++;
			}
		}

		private static int LookAhead(char[] json, int index)
		{
			int index2 = index;
			return NextToken(json, ref index2);
		}

		private static int NextToken(char[] json, ref int index)
		{
			EatWhitespace(json, ref index);
			if (index == json.Length)
			{
				return 0;
			}
			char c = json[index];
			index++;
			switch (c)
			{
			case '{':
				return 1;
			case '}':
				return 2;
			case '[':
				return 3;
			case ']':
				return 4;
			case ',':
				return 6;
			case '"':
				return 7;
			case '-':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				return 8;
			case ':':
				return 5;
			default:
			{
				index--;
				int num = json.Length - index;
				if (num >= 5 && json[index] == 'f' && json[index + 1] == 'a' && json[index + 2] == 'l' && json[index + 3] == 's' && json[index + 4] == 'e')
				{
					index += 5;
					return 10;
				}
				if (num >= 4 && json[index] == 't' && json[index + 1] == 'r' && json[index + 2] == 'u' && json[index + 3] == 'e')
				{
					index += 4;
					return 9;
				}
				if (num >= 4 && json[index] == 'n' && json[index + 1] == 'u' && json[index + 2] == 'l' && json[index + 3] == 'l')
				{
					index += 4;
					return 11;
				}
				return 0;
			}
			}
		}

		private static bool SerializeValue(IJsonSerializerStrategy jsonSerializerStrategy, object value, StringBuilder builder)
		{
			bool flag = true;
			if (value is string aString)
			{
				flag = SerializeString(aString, builder);
			}
			else if (value is IDictionary<string, object> dictionary)
			{
				flag = SerializeObject(jsonSerializerStrategy, dictionary.Keys, dictionary.Values, builder);
			}
			else if (value is IDictionary<string, string> dictionary2)
			{
				flag = SerializeObject(jsonSerializerStrategy, dictionary2.Keys, dictionary2.Values, builder);
			}
			else if (value is IEnumerable anArray)
			{
				flag = SerializeArray(jsonSerializerStrategy, anArray, builder);
			}
			else if (IsNumeric(value))
			{
				flag = SerializeNumber(value, builder);
			}
			else if (value is bool)
			{
				builder.Append(((bool)value) ? "true" : "false");
			}
			else if (value == null)
			{
				builder.Append("null");
			}
			else
			{
				flag = jsonSerializerStrategy.TrySerializeNonPrimitiveObject(value, out var output);
				if (flag)
				{
					SerializeValue(jsonSerializerStrategy, output, builder);
				}
			}
			return flag;
		}

		private static bool SerializeObject(IJsonSerializerStrategy jsonSerializerStrategy, IEnumerable keys, IEnumerable values, StringBuilder builder)
		{
			builder.Append("{");
			IEnumerator enumerator = keys.GetEnumerator();
			IEnumerator enumerator2 = values.GetEnumerator();
			bool flag = true;
			while (enumerator.MoveNext() && enumerator2.MoveNext())
			{
				object current = enumerator.Current;
				object current2 = enumerator2.Current;
				if (!flag)
				{
					builder.Append(",");
				}
				if (current is string aString)
				{
					SerializeString(aString, builder);
				}
				else if (!SerializeValue(jsonSerializerStrategy, current2, builder))
				{
					return false;
				}
				builder.Append(":");
				if (!SerializeValue(jsonSerializerStrategy, current2, builder))
				{
					return false;
				}
				flag = false;
			}
			builder.Append("}");
			return true;
		}

		private static bool SerializeArray(IJsonSerializerStrategy jsonSerializerStrategy, IEnumerable anArray, StringBuilder builder)
		{
			builder.Append("[");
			bool flag = true;
			foreach (object item in anArray)
			{
				if (!flag)
				{
					builder.Append(",");
				}
				if (!SerializeValue(jsonSerializerStrategy, item, builder))
				{
					return false;
				}
				flag = false;
			}
			builder.Append("]");
			return true;
		}

		private static bool SerializeString(string aString, StringBuilder builder)
		{
			if (aString.IndexOfAny(EscapeCharacters) == -1)
			{
				builder.Append('"');
				builder.Append(aString);
				builder.Append('"');
				return true;
			}
			builder.Append('"');
			int num = 0;
			char[] array = aString.ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				char c = array[i];
				if (c >= EscapeTable.Length || EscapeTable[(uint)c] == '\0')
				{
					num++;
					continue;
				}
				if (num > 0)
				{
					builder.Append(array, i - num, num);
					num = 0;
				}
				builder.Append('\\');
				builder.Append(EscapeTable[(uint)c]);
			}
			if (num > 0)
			{
				builder.Append(array, array.Length - num, num);
			}
			builder.Append('"');
			return true;
		}

		private static bool SerializeNumber(object number, StringBuilder builder)
		{
			if (number is long)
			{
				builder.Append(((long)number).ToString(CultureInfo.InvariantCulture));
			}
			else if (number is ulong)
			{
				builder.Append(((ulong)number).ToString(CultureInfo.InvariantCulture));
			}
			else if (number is int)
			{
				builder.Append(((int)number).ToString(CultureInfo.InvariantCulture));
			}
			else if (number is uint)
			{
				builder.Append(((uint)number).ToString(CultureInfo.InvariantCulture));
			}
			else if (number is decimal)
			{
				builder.Append(((decimal)number).ToString(CultureInfo.InvariantCulture));
			}
			else if (number is float)
			{
				builder.Append(((float)number).ToString(CultureInfo.InvariantCulture));
			}
			else
			{
				builder.Append(Convert.ToDouble(number, CultureInfo.InvariantCulture).ToString("r", CultureInfo.InvariantCulture));
			}
			return true;
		}

		private static bool IsNumeric(object value)
		{
			if (value is sbyte)
			{
				return true;
			}
			if (value is byte)
			{
				return true;
			}
			if (value is short)
			{
				return true;
			}
			if (value is ushort)
			{
				return true;
			}
			if (value is int)
			{
				return true;
			}
			if (value is uint)
			{
				return true;
			}
			if (value is long)
			{
				return true;
			}
			if (value is ulong)
			{
				return true;
			}
			if (value is float)
			{
				return true;
			}
			if (value is double)
			{
				return true;
			}
			if (value is decimal)
			{
				return true;
			}
			return false;
		}
	}
	[GeneratedCode("simple-json", "1.0.0")]
	public interface IJsonSerializerStrategy
	{
		bool TrySerializeNonPrimitiveObject(object input, out object output);

		object DeserializeObject(object value, Type type);
	}
	[GeneratedCode("simple-json", "1.0.0")]
	public class PocoJsonSerializerStrategy : IJsonSerializerStrategy
	{
		internal IDictionary<Type, ReflectionUtils.ConstructorDelegate> ConstructorCache;

		internal IDictionary<Type, IDictionary<string, ReflectionUtils.GetDelegate>> GetCache;

		internal IDictionary<Type, IDictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>>> SetCache;

		internal static readonly Type[] EmptyTypes = new Type[0];

		internal static readonly Type[] ArrayConstructorParameterTypes = new Type[1] { typeof(int) };

		private static readonly string[] Iso8601Format = new string[3] { "yyyy-MM-dd\\THH:mm:ss.FFFFFFF\\Z", "yyyy-MM-dd\\THH:mm:ss\\Z", "yyyy-MM-dd\\THH:mm:ssK" };

		public PocoJsonSerializerStrategy()
		{
			ConstructorCache = new ReflectionUtils.ThreadSafeDictionary<Type, ReflectionUtils.ConstructorDelegate>(ContructorDelegateFactory);
			GetCache = new ReflectionUtils.ThreadSafeDictionary<Type, IDictionary<string, ReflectionUtils.GetDelegate>>(GetterValueFactory);
			SetCache = new ReflectionUtils.ThreadSafeDictionary<Type, IDictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>>>(SetterValueFactory);
		}

		protected virtual string MapClrMemberNameToJsonFieldName(string clrPropertyName)
		{
			return clrPropertyName;
		}

		internal virtual ReflectionUtils.ConstructorDelegate ContructorDelegateFactory(Type key)
		{
			return ReflectionUtils.GetContructor(key, key.IsArray ? ArrayConstructorParameterTypes : EmptyTypes);
		}

		internal virtual IDictionary<string, ReflectionUtils.GetDelegate> GetterValueFactory(Type type)
		{
			IDictionary<string, ReflectionUtils.GetDelegate> dictionary = new Dictionary<string, ReflectionUtils.GetDelegate>();
			foreach (PropertyInfo property in ReflectionUtils.GetProperties(type))
			{
				if (property.CanRead)
				{
					MethodInfo getterMethodInfo = ReflectionUtils.GetGetterMethodInfo(property);
					if (!getterMethodInfo.IsStatic && getterMethodInfo.IsPublic)
					{
						dictionary[MapClrMemberNameToJsonFieldName(property.Name)] = ReflectionUtils.GetGetMethod(property);
					}
				}
			}
			foreach (FieldInfo field in ReflectionUtils.GetFields(type))
			{
				if (!field.IsStatic && field.IsPublic)
				{
					dictionary[MapClrMemberNameToJsonFieldName(field.Name)] = ReflectionUtils.GetGetMethod(field);
				}
			}
			return dictionary;
		}

		internal virtual IDictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>> SetterValueFactory(Type type)
		{
			IDictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>> dictionary = new Dictionary<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>>();
			foreach (PropertyInfo property in ReflectionUtils.GetProperties(type))
			{
				if (property.CanWrite)
				{
					MethodInfo setterMethodInfo = ReflectionUtils.GetSetterMethodInfo(property);
					if (!setterMethodInfo.IsStatic && setterMethodInfo.IsPublic)
					{
						dictionary[MapClrMemberNameToJsonFieldName(property.Name)] = new KeyValuePair<Type, ReflectionUtils.SetDelegate>(property.PropertyType, ReflectionUtils.GetSetMethod(property));
					}
				}
			}
			foreach (FieldInfo field in ReflectionUtils.GetFields(type))
			{
				if (!field.IsInitOnly && !field.IsStatic && field.IsPublic)
				{
					dictionary[MapClrMemberNameToJsonFieldName(field.Name)] = new KeyValuePair<Type, ReflectionUtils.SetDelegate>(field.FieldType, ReflectionUtils.GetSetMethod(field));
				}
			}
			return dictionary;
		}

		public virtual bool TrySerializeNonPrimitiveObject(object input, out object output)
		{
			if (!TrySerializeKnownTypes(input, out output))
			{
				return TrySerializeUnknownTypes(input, out output);
			}
			return true;
		}

		public virtual object DeserializeObject(object value, Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			string text = value as string;
			if (type == typeof(Guid) && string.IsNullOrEmpty(text))
			{
				return default(Guid);
			}
			if (value == null)
			{
				return null;
			}
			object obj = null;
			if (text != null)
			{
				if (text.Length != 0)
				{
					if (type == typeof(DateTime) || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(DateTime)))
					{
						return DateTime.ParseExact(text, Iso8601Format, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
					}
					if (type == typeof(DateTimeOffset) || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(DateTimeOffset)))
					{
						return DateTimeOffset.ParseExact(text, Iso8601Format, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
					}
					if (type == typeof(Guid) || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(Guid)))
					{
						return new Guid(text);
					}
					if (type == typeof(Uri))
					{
						if (Uri.IsWellFormedUriString(text, UriKind.RelativeOrAbsolute) && Uri.TryCreate(text, UriKind.RelativeOrAbsolute, out Uri result))
						{
							return result;
						}
						return null;
					}
					if (type == typeof(string))
					{
						return text;
					}
					return Convert.ChangeType(text, type, CultureInfo.InvariantCulture);
				}
				obj = ((type == typeof(Guid)) ? ((object)default(Guid)) : ((!ReflectionUtils.IsNullableType(type) || !(Nullable.GetUnderlyingType(type) == typeof(Guid))) ? text : null));
				if (!ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type) == typeof(Guid))
				{
					return text;
				}
			}
			else if (value is bool)
			{
				return value;
			}
			bool flag = value is long;
			bool flag2 = value is double;
			if ((flag && type == typeof(long)) || (flag2 && type == typeof(double)))
			{
				return value;
			}
			if ((flag2 && type != typeof(double)) || (flag && type != typeof(long)))
			{
				obj = ((type == typeof(int) || type == typeof(long) || type == typeof(double) || type == typeof(float) || type == typeof(bool) || type == typeof(decimal) || type == typeof(byte) || type == typeof(short)) ? Convert.ChangeType(value, type, CultureInfo.InvariantCulture) : value);
			}
			else
			{
				if (!(value is JsonArray) || !ReflectionUtils.IsTypeDictionary(type))
				{
					if (value is IDictionary<string, object> dictionary)
					{
						IDictionary<string, object> dictionary2 = dictionary;
						if (ReflectionUtils.IsTypeDictionary(type))
						{
							Type[] genericTypeArguments = ReflectionUtils.GetGenericTypeArguments(type);
							Type type2 = genericTypeArguments[0];
							Type type3 = genericTypeArguments[1];
							Type key = typeof(Dictionary<, >).MakeGenericType(type2, type3);
							IDictionary dictionary3 = (IDictionary)ConstructorCache[key]();
							foreach (KeyValuePair<string, object> item in dictionary2)
							{
								dictionary3.Add(item.Key, DeserializeObject(item.Value, type3));
							}
							obj = dictionary3;
						}
						else if (type == typeof(object))
						{
							obj = value;
						}
						else
						{
							ReflectionUtils.ConstructorDelegate constructorDelegate = ConstructorCache[type];
							if (constructorDelegate == null)
							{
								throw new MissingMethodException($"No default constructor found for {type}");
							}
							obj = constructorDelegate();
							foreach (KeyValuePair<string, KeyValuePair<Type, ReflectionUtils.SetDelegate>> item2 in SetCache[type])
							{
								if (dictionary2.TryGetValue(item2.Key, out var value2))
								{
									value2 = DeserializeObject(value2, item2.Value.Key);
									item2.Value.Value(obj, value2);
								}
							}
						}
					}
					else if (value is IList<object> list)
					{
						IList<object> list2 = list;
						IList list3 = null;
						if (type.IsArray)
						{
							list3 = (IList)ConstructorCache[type](list2.Count);
							int num = 0;
							foreach (object item3 in list2)
							{
								list3[num++] = DeserializeObject(item3, type.GetElementType());
							}
						}
						else if (ReflectionUtils.IsTypeGenericeCollectionInterface(type) || ReflectionUtils.IsAssignableFrom(typeof(IList), type))
						{
							Type genericListElementType = ReflectionUtils.GetGenericListElementType(type);
							list3 = (IList)(ConstructorCache[type] ?? ConstructorCache[typeof(List<>).MakeGenericType(genericListElementType)])(list2.Count);
							foreach (object item4 in list2)
							{
								list3.Add(DeserializeObject(item4, genericListElementType));
							}
						}
						obj = list3;
					}
					return obj;
				}
				JsonArray jsonArray = (JsonArray)value;
				Type[] genericTypeArguments2 = ReflectionUtils.GetGenericTypeArguments(type);
				Type type4 = genericTypeArguments2[0];
				Type type5 = genericTypeArguments2[1];
				Type key2 = typeof(Dictionary<, >).MakeGenericType(type4, type5);
				IDictionary dictionary4 = (IDictionary)ConstructorCache[key2]();
				foreach (JsonObject item5 in jsonArray)
				{
					dictionary4.Add(DeserializeObject(item5[0], type4), DeserializeObject(item5[1], type5));
				}
				obj = dictionary4;
			}
			if (ReflectionUtils.IsNullableType(type))
			{
				return ReflectionUtils.ToNullableType(obj, type);
			}
			return obj;
		}

		protected virtual object SerializeEnum(Enum p)
		{
			return Convert.ToDouble(p, CultureInfo.InvariantCulture);
		}

		protected virtual bool TrySerializeKnownTypes(object input, out object output)
		{
			bool result = true;
			if (input is DateTime)
			{
				output = ((DateTime)input).ToUniversalTime().ToString(Iso8601Format[0], CultureInfo.InvariantCulture);
			}
			else if (input is DateTimeOffset)
			{
				output = ((DateTimeOffset)input).ToUniversalTime().ToString(Iso8601Format[0], CultureInfo.InvariantCulture);
			}
			else if (input is Guid)
			{
				output = ((Guid)input).ToString("D");
			}
			else if (input is Uri)
			{
				output = input.ToString();
			}
			else if (input is Enum p)
			{
				output = SerializeEnum(p);
			}
			else
			{
				result = false;
				output = null;
			}
			return result;
		}

		protected virtual bool TrySerializeUnknownTypes(object input, out object output)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			output = null;
			Type type = input.GetType();
			if (type.FullName == null)
			{
				return false;
			}
			IDictionary<string, object> dictionary = new JsonObject();
			IDictionary<string, ReflectionUtils.GetDelegate> dictionary2 = GetCache[type];
			foreach (KeyValuePair<string, ReflectionUtils.GetDelegate> item in dictionary2)
			{
				if (item.Value != null)
				{
					dictionary.Add(MapClrMemberNameToJsonFieldName(item.Key), item.Value(input));
				}
			}
			output = dictionary;
			return true;
		}
	}
}
namespace SimpleJson.Reflection
{
	[GeneratedCode("reflection-utils", "1.0.0")]
	internal class ReflectionUtils
	{
		public delegate object GetDelegate(object source);

		public delegate void SetDelegate(object source, object value);

		public delegate object ConstructorDelegate(params object[] args);

		public delegate TValue ThreadSafeDictionaryValueFactory<TKey, TValue>(TKey key);

		private static class Assigner<T>
		{
			public static T Assign(ref T left, T right)
			{
				return left = right;
			}
		}

		public sealed class ThreadSafeDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
		{
			private readonly object _lock = new object();

			private readonly ThreadSafeDictionaryValueFactory<TKey, TValue> _valueFactory;

			private Dictionary<TKey, TValue> _dictionary;

			public ICollection<TKey> Keys => _dictionary.Keys;

			public ICollection<TValue> Values => _dictionary.Values;

			public TValue this[TKey key]
			{
				get
				{
					return Get(key);
				}
				set
				{
					throw new NotImplementedException();
				}
			}

			public int Count => _dictionary.Count;

			public bool IsReadOnly
			{
				get
				{
					throw new NotImplementedException();
				}
			}

			public ThreadSafeDictionary(ThreadSafeDictionaryValueFactory<TKey, TValue> valueFactory)
			{
				_valueFactory = valueFactory;
			}

			private TValue Get(TKey key)
			{
				if (_dictionary == null)
				{
					return AddValue(key);
				}
				if (!_dictionary.TryGetValue(key, out var value))
				{
					return AddValue(key);
				}
				return value;
			}

			private TValue AddValue(TKey key)
			{
				TValue val = _valueFactory(key);
				lock (_lock)
				{
					if (_dictionary == null)
					{
						_dictionary = new Dictionary<TKey, TValue>();
						_dictionary[key] = val;
					}
					else
					{
						if (_dictionary.TryGetValue(key, out var value))
						{
							return value;
						}
						Dictionary<TKey, TValue> dictionary = new Dictionary<TKey, TValue>(_dictionary);
						dictionary[key] = val;
						_dictionary = dictionary;
					}
				}
				return val;
			}

			public void Add(TKey key, TValue value)
			{
				throw new NotImplementedException();
			}

			public bool ContainsKey(TKey key)
			{
				return _dictionary.ContainsKey(key);
			}

			public bool Remove(TKey key)
			{
				throw new NotImplementedException();
			}

			public bool TryGetValue(TKey key, out TValue value)
			{
				value = this[key];
				return true;
			}

			public void Add(KeyValuePair<TKey, TValue> item)
			{
				throw new NotImplementedException();
			}

			public void Clear()
			{
				throw new NotImplementedException();
			}

			public bool Contains(KeyValuePair<TKey, TValue> item)
			{
				throw new NotImplementedException();
			}

			public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
			{
				throw new NotImplementedException();
			}

			public bool Remove(KeyValuePair<TKey, TValue> item)
			{
				throw new NotImplementedException();
			}

			public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
			{
				return _dictionary.GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return _dictionary.GetEnumerator();
			}
		}

		private static readonly object[] EmptyObjects = new object[0];

		public static Type GetTypeInfo(Type type)
		{
			return type;
		}

		public static Attribute GetAttribute(MemberInfo info, Type type)
		{
			if (info == null || type == null || !Attribute.IsDefined(info, type))
			{
				return null;
			}
			return Attribute.GetCustomAttribute(info, type);
		}

		public static Type GetGenericListElementType(Type type)
		{
			IEnumerable<Type> interfaces = type.GetInterfaces();
			foreach (Type item in interfaces)
			{
				if (IsTypeGeneric(item) && item.GetGenericTypeDefinition() == typeof(IList<>))
				{
					return GetGenericTypeArguments(item)[0];
				}
			}
			return GetGenericTypeArguments(type)[0];
		}

		public static Attribute GetAttribute(Type objectType, Type attributeType)
		{
			if (objectType == null || attributeType == null || !Attribute.IsDefined(objectType, attributeType))
			{
				return null;
			}
			return Attribute.GetCustomAttribute(objectType, attributeType);
		}

		public static Type[] GetGenericTypeArguments(Type type)
		{
			return type.GetGenericArguments();
		}

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

		public static bool IsTypeGenericeCollectionInterface(Type type)
		{
			if (!IsTypeGeneric(type))
			{
				return false;
			}
			Type genericTypeDefinition = type.GetGenericTypeDefinition();
			if (!(genericTypeDefinition == typeof(IList<>)) && !(genericTypeDefinition == typeof(ICollection<>)))
			{
				return genericTypeDefinition == typeof(IEnumerable<>);
			}
			return true;
		}

		public static bool IsAssignableFrom(Type type1, Type type2)
		{
			return GetTypeInfo(type1).IsAssignableFrom(GetTypeInfo(type2));
		}

		public static bool IsTypeDictionary(Type type)
		{
			if (typeof(IDictionary).IsAssignableFrom(type))
			{
				return true;
			}
			if (!GetTypeInfo(type).IsGenericType)
			{
				return false;
			}
			Type genericTypeDefinition = type.GetGenericTypeDefinition();
			return genericTypeDefinition == typeof(IDictionary<, >);
		}

		public static bool IsNullableType(Type type)
		{
			if (GetTypeInfo(type).IsGenericType)
			{
				return type.GetGenericTypeDefinition() == typeof(Nullable<>);
			}
			return false;
		}

		public static object ToNullableType(object obj, Type nullableType)
		{
			if (obj != null)
			{
				return Convert.ChangeType(obj, Nullable.GetUnderlyingType(nullableType), CultureInfo.InvariantCulture);
			}
			return null;
		}

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

		public static IEnumerable<ConstructorInfo> GetConstructors(Type type)
		{
			return type.GetConstructors();
		}

		public static ConstructorInfo GetConstructorInfo(Type type, params Type[] argsType)
		{
			IEnumerable<ConstructorInfo> constructors = GetConstructors(type);
			foreach (ConstructorInfo item in constructors)
			{
				ParameterInfo[] parameters = item.GetParameters();
				if (argsType.Length != parameters.Length)
				{
					continue;
				}
				int num = 0;
				bool flag = true;
				ParameterInfo[] parameters2 = item.GetParameters();
				foreach (ParameterInfo parameterInfo in parameters2)
				{
					if (parameterInfo.ParameterType != argsType[num])
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return item;
				}
			}
			return null;
		}

		public static IEnumerable<PropertyInfo> GetProperties(Type type)
		{
			return type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

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

		public static MethodInfo GetGetterMethodInfo(PropertyInfo propertyInfo)
		{
			return propertyInfo.GetGetMethod(nonPublic: true);
		}

		public static MethodInfo GetSetterMethodInfo(PropertyInfo propertyInfo)
		{
			return propertyInfo.GetSetMethod(nonPublic: true);
		}

		public static ConstructorDelegate GetContructor(ConstructorInfo constructorInfo)
		{
			return GetConstructorByExpression(constructorInfo);
		}

		public static ConstructorDelegate GetContructor(Type type, params Type[] argsType)
		{
			return GetConstructorByExpression(type, argsType);
		}

		public static ConstructorDelegate GetConstructorByReflection(ConstructorInfo constructorInfo)
		{
			return (object[] args) => constructorInfo.Invoke(args);
		}

		public static ConstructorDelegate GetConstructorByReflection(Type type, params Type[] argsType)
		{
			ConstructorInfo constructorInfo = GetConstructorInfo(type, argsType);
			if (!(constructorInfo == null))
			{
				return GetConstructorByReflection(constructorInfo);
			}
			return null;
		}

		public static ConstructorDelegate GetConstructorByExpression(ConstructorInfo constructorInfo)
		{
			ParameterInfo[] parameters = constructorInfo.GetParameters();
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object[]), "args");
			Expression[] array = new Expression[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				Expression index = Expression.Constant(i);
				Type parameterType = parameters[i].ParameterType;
				Expression expression = Expression.ArrayIndex(parameterExpression, index);
				Expression expression2 = Expression.Convert(expression, parameterType);
				array[i] = expression2;
			}
			NewExpression body = Expression.New(constructorInfo, array);
			Expression<Func<object[], object>> expression3 = Expression.Lambda<Func<object[], object>>(body, new ParameterExpression[1] { parameterExpression });
			Func<object[], object> compiledLambda = expression3.Compile();
			return (object[] args) => compiledLambda(args);
		}

		public static ConstructorDelegate GetConstructorByExpression(Type type, params Type[] argsType)
		{
			ConstructorInfo constructorInfo = GetConstructorInfo(type, argsType);
			if (!(constructorInfo == null))
			{
				return GetConstructorByExpression(constructorInfo);
			}
			return null;
		}

		public static GetDelegate GetGetMethod(PropertyInfo propertyInfo)
		{
			return GetGetMethodByExpression(propertyInfo);
		}

		public static GetDelegate GetGetMethod(FieldInfo fieldInfo)
		{
			return GetGetMethodByExpression(fieldInfo);
		}

		public static GetDelegate GetGetMethodByReflection(PropertyInfo propertyInfo)
		{
			MethodInfo methodInfo = GetGetterMethodInfo(propertyInfo);
			return (object source) => methodInfo.Invoke(source, EmptyObjects);
		}

		public static GetDelegate GetGetMethodByReflection(FieldInfo fieldInfo)
		{
			return (object source) => fieldInfo.GetValue(source);
		}

		public static GetDelegate GetGetMethodByExpression(PropertyInfo propertyInfo)
		{
			MethodInfo getterMethodInfo = GetGetterMethodInfo(propertyInfo);
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "instance");
			UnaryExpression instance = ((!IsValueType(propertyInfo.DeclaringType)) ? Expression.TypeAs(parameterExpression, propertyInfo.DeclaringType) : Expression.Convert(parameterExpression, propertyInfo.DeclaringType));
			Func<object, object> compiled = Expression.Lambda<Func<object, object>>(Expression.TypeAs(Expression.Call(instance, getterMethodInfo), typeof(object)), new ParameterExpression[1] { parameterExpression }).Compile();
			return (object source) => compiled(source);
		}

		public static GetDelegate GetGetMethodByExpression(FieldInfo fieldInfo)
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "instance");
			MemberExpression expression = Expression.Field(Expression.Convert(parameterExpression, fieldInfo.DeclaringType), fieldInfo);
			GetDelegate compiled = Expression.Lambda<GetDelegate>(Expression.Convert(expression, typeof(object)), new ParameterExpression[1] { parameterExpression }).Compile();
			return (object source) => compiled(source);
		}

		public static SetDelegate GetSetMethod(PropertyInfo propertyInfo)
		{
			return GetSetMethodByExpression(propertyInfo);
		}

		public static SetDelegate GetSetMethod(FieldInfo fieldInfo)
		{
			return GetSetMethodByExpression(fieldInfo);
		}

		public static SetDelegate GetSetMethodByReflection(PropertyInfo propertyInfo)
		{
			MethodInfo methodInfo = GetSetterMethodInfo(propertyInfo);
			return delegate(object source, object value)
			{
				methodInfo.Invoke(source, new object[1] { value });
			};
		}

		public static SetDelegate GetSetMethodByReflection(FieldInfo fieldInfo)
		{
			return delegate(object source, object value)
			{
				fieldInfo.SetValue(source, value);
			};
		}

		public static SetDelegate GetSetMethodByExpression(PropertyInfo propertyInfo)
		{
			MethodInfo setterMethodInfo = GetSetterMethodInfo(propertyInfo);
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "instance");
			ParameterExpression parameterExpression2 = Expression.Parameter(typeof(object), "value");
			UnaryExpression instance = ((!IsValueType(propertyInfo.DeclaringType)) ? Expression.TypeAs(parameterExpression, propertyInfo.DeclaringType) : Expression.Convert(parameterExpression, propertyInfo.DeclaringType));
			UnaryExpression unaryExpression = ((!IsValueType(propertyInfo.PropertyType)) ? Expression.TypeAs(parameterExpression2, propertyInfo.PropertyType) : Expression.Convert(parameterExpression2, propertyInfo.PropertyType));
			Action<object, object> compiled = Expression.Lambda<Action<object, object>>(Expression.Call(instance, setterMethodInfo, unaryExpression), new ParameterExpression[2] { parameterExpression, parameterExpression2 }).Compile();
			return delegate(object source, object val)
			{
				compiled(source, val);
			};
		}

		public static SetDelegate GetSetMethodByExpression(FieldInfo fieldInfo)
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "instance");
			ParameterExpression parameterExpression2 = Expression.Parameter(typeof(object), "value");
			Action<object, object> compiled = Expression.Lambda<Action<object, object>>(Assign(Expression.Field(Expression.Convert(parameterExpression, fieldInfo.DeclaringType), fieldInfo), Expression.Convert(parameterExpression2, fieldInfo.FieldType)), new ParameterExpression[2] { parameterExpression, parameterExpression2 }).Compile();
			return delegate(object source, object val)
			{
				compiled(source, val);
			};
		}

		public static BinaryExpression Assign(Expression left, Expression right)
		{
			MethodInfo method = typeof(Assigner<>).MakeGenericType(left.Type).GetMethod("Assign");
			return Expression.Add(left, right, method);
		}
	}
}
namespace Jotunn
{
	public static class ArrayExtensions
	{
		public static T[] Populate<T>(this T[] arr, T value)
		{
			for (int i = 0; i < arr.Length; i++)
			{
				arr[i] = value;
			}
			return arr;
		}
	}
	public static class ConfigEntryBaseExtension
	{
		public static bool IsVisible(this ConfigEntryBase configurationEntry)
		{
			ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes();
			ConfigDescription description = configurationEntry.Description;
			configurationManagerAttributes.SetFromAttributes((description != null) ? description.Tags : null);
			return configurationManagerAttributes.Browsable != false;
		}

		public static bool IsSyncable(this ConfigEntryBase configurationEntry)
		{
			if (configurationEntry.Description.Tags.FirstOrDefault((object x) => x is ConfigurationManagerAttributes) is ConfigurationManagerAttributes configurationManagerAttributes)
			{
				return configurationManagerAttributes.IsAdminOnly;
			}
			return false;
		}

		public static string GetBoundButtonName(this ConfigEntryBase configurationEntry)
		{
			if (configurationEntry == null)
			{
				throw new ArgumentNullException("configurationEntry");
			}
			if (configurationEntry.SettingType != typeof(KeyCode) && configurationEntry.SettingType != typeof(KeyboardShortcut) && configurationEntry.SettingType != typeof(InputManager.GamepadButton))
			{
				return null;
			}
			if (!InputManager.ButtonToConfigDict.TryGetValue(configurationEntry, out var value))
			{
				return null;
			}
			return value.Name;
		}

		public static ButtonConfig GetButtonConfig(this ConfigEntryBase configurationEntry)
		{
			if (configurationEntry == null)
			{
				throw new ArgumentNullException("configurationEntry");
			}
			if (configurationEntry.SettingType != typeof(KeyCode) && configurationEntry.SettingType != typeof(KeyboardShortcut) && configurationEntry.SettingType != typeof(InputManager.GamepadButton))
			{
				return null;
			}
			InputManager.ButtonToConfigDict.TryGetValue(configurationEntry, out var value);
			return value;
		}

		internal static object GetLocalValue(this ConfigEntryBase configurationEntry)
		{
			if (SynchronizationManager.Instance.localValues.TryGetValue(configurationEntry, out var value))
			{
				return value;
			}
			return null;
		}

		internal static void SetLocalValue(this ConfigEntryBase configurationEntry, object value)
		{
			SynchronizationManager.Instance.localValues[configurationEntry] = value;
		}

		internal static ConfigurationManagerAttributes GetConfigurationManagerAttributes(this ConfigEntryBase configEntry)
		{
			return (ConfigurationManagerAttributes)configEntry.Description.Tags.FirstOrDefault((object x) => x is ConfigurationManagerAttributes);
		}
	}
	internal static class EventExtensions
	{
		public static void SafeInvoke(this Action events)
		{
			if (events == null)
			{
				return;
			}
			Delegate[] invocationList = events.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action = (Action)invocationList[i];
				try
				{
					action();
				}
				catch (Exception ex)
				{
					Logger.LogWarning($"Exception thrown at event {new StackFrame(1).GetMethod().Name} in {action.Method.DeclaringType.Name}.{action.Method.Name}:\n{ex}");
				}
			}
		}

		public static void SafeInvoke<TArg1>(this Action<TArg1> events, TArg1 arg1)
		{
			if (events == null)
			{
				return;
			}
			Delegate[] invocationList = events.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<TArg1> action = (Action<TArg1>)invocationList[i];
				try
				{
					action(arg1);
				}
				catch (Exception ex)
				{
					Logger.LogWarning($"Exception thrown at event {new StackFrame(1).GetMethod().Name} in {action.Method.DeclaringType.Name}.{action.Method.Name}:\n{ex}");
				}
			}
		}

		public static void SafeInvoke<TArg1, TArg2>(this Action<TArg1, TArg2> events, TArg1 arg1, TArg2 arg2)
		{
			if (events == null)
			{
				return;
			}
			Delegate[] invocationList = events.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<TArg1, TArg2> action = (Action<TArg1, TArg2>)invocationList[i];
				try
				{
					action(arg1, arg2);
				}
				catch (Exception ex)
				{
					Logger.LogWarning($"Exception thrown at event {new StackFrame(1).GetMethod().Name} in {action.Method.DeclaringType.Name}.{action.Method.Name}:\n{ex}");
				}
			}
		}

		public static void SafeInvoke<TEventArg>(this EventHandler<TEventArg> events, object sender, TEventArg arg1)
		{
			if (events == null)
			{
				return;
			}
			Delegate[] invocationList = events.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				EventHandler<TEventArg> eventHandler = (EventHandler<TEventArg>)invocationList[i];
				try
				{
					eventHandler(sender, arg1);
				}
				catch (Exception ex)
				{
					Logger.LogWarning($"Exception thrown at event {new StackFrame(1).GetMethod().Name} in {eventHandler.Method.DeclaringType.Name}.{eventHandler.Method.Name}:\n{ex}");
				}
			}
		}
	}
	public static class ExposedGameObjectExtension
	{
		public static GameObject OrNull(this GameObject @this)
		{
			if (!Object.op_Implicit((Object)(object)@this))
			{
				return null;
			}
			return @this;
		}

		public static T OrNull<T>(this T @this) where T : Object
		{
			if (!Object.op_Implicit((Object)(object)@this))
			{
				return default(T);
			}
			return @this;
		}

		public static T GetOrAddComponent<T>(this GameObject gameObject) where T : Component
		{
			T result = default(T);
			if (!gameObject.TryGetComponent<T>(ref result))
			{
				return gameObject.AddComponent<T>();
			}
			return result;
		}

		public static Component AddComponentCopy<T>(this GameObject gameObject, T duplicate) where T : Component
		{
			Component val = gameObject.AddComponent(((object)duplicate).GetType());
			PropertyInfo[] properties = ((object)duplicate).GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (PropertyInfo propertyInfo in properties)
			{
				switch (propertyInfo.Name)
				{
				case "mesh":
					if (duplicate is MeshFilter)
					{
						continue;
					}
					break;
				case "material":
				case "materials":
					if (duplicate is Renderer)
					{
						continue;
					}
					break;
				case "bounds":
					if (duplicate is Renderer)
					{
						continue;
					}
					break;
				case "name":
				case "rayTracingMode":
				case "tag":
					continue;
				}
				if (propertyInfo.CanWrite && propertyInfo.GetMethod != null)
				{
					propertyInfo.SetValue(val, propertyInfo.GetValue(duplicate));
				}
			}
			FieldInfo[] fields = ((object)duplicate).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (!(fieldInfo.Name == "rayTracingMode"))
				{
					fieldInfo.SetValue(val, fieldInfo.GetValue(duplicate));
				}
			}
			return val;
		}

		public static bool HasAnyComponent(this GameObject gameObject, params Type[] components)
		{
			foreach (Type type in components)
			{
				if (Object.op_Implicit((Object)(object)gameObject.GetComponent(type)))
				{
					return true;
				}
			}
			return false;
		}

		public static bool HasAnyComponent(this GameObject gameObject, params string[] componentNames)
		{
			foreach (string text in componentNames)
			{
				if (Object.op_Implicit((Object)(object)gameObject.GetComponent(text)))
				{
					return true;
				}
			}
			return false;
		}

		public static bool HasAllComponents(this GameObject gameObject, params string[] componentNames)
		{
			foreach (string text in componentNames)
			{
				if (!Object.op_Implicit((Object)(object)gameObject.GetComponent(text)))
				{
					return false;
				}
			}
			return true;
		}

		public static bool HasAllComponents(this GameObject gameObject, params Type[] components)
		{
			foreach (Type type in components)
			{
				if (!Object.op_Implicit((Object)(object)gameObject.GetComponent(type)))
				{
					return false;
				}
			}
			return true;
		}

		public static bool HasAnyComponentInChildren(this GameObject gameObject, bool includeInactive = false, params Type[] components)
		{
			foreach (Type type in components)
			{
				if (Object.op_Implicit((Object)(object)gameObject.GetComponentInChildren(type, includeInactive)))
				{
					return true;
				}
			}
			return false;
		}

		public static Transform FindDeepChild(this GameObject gameObject, string childName, IterativeSearchType searchType = (IterativeSearchType)1)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return gameObject.transform.FindDeepChild(childName, searchType);
		}

		public static Transform FindDeepChild(this GameObject gameObject, IEnumerable<string> childNames, IterativeSearchType searchType = (IterativeSearchType)1)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Transform val = gameObject.transform;
			foreach (string childName in childNames)
			{
				val = val.FindDeepChild(childName, searchType);
				if (!Object.op_Implicit((Object)(object)val))
				{
					return null;
				}
			}
			return val;
		}
	}
	internal static class GameObjectGUIExtension
	{
		internal static GameObject SetToTextHeight(this GameObject go)
		{
			go.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, go.GetComponentInChildren<Text>().preferredHeight + 3f);
			return go;
		}

		internal static GameObject SetUpperLeft(this GameObject go)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(0f, 1f);
			component.anchorMin = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(0f, 0f);
			return go;
		}

		internal static GameObject SetMiddleLeft(this GameObject go)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(0f, 0.5f);
			component.anchorMin = new Vector2(0f, 0.5f);
			component.pivot = new Vector2(0f, 0.5f);
			component.anchoredPosition = new Vector2(0f, 0f);
			return go;
		}

		internal static GameObject SetBottomLeft(this GameObject go)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(0f, 0f);
			component.anchorMin = new Vector2(0f, 0f);
			component.pivot = new Vector2(0f, 0f);
			component.anchoredPosition = new Vector2(0f, 0f);
			return go;
		}

		internal static GameObject SetUpperRight(this GameObject go)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(1f, 1f);
			component.anchorMin = new Vector2(1f, 1f);
			component.pivot = new Vector2(1f, 1f);
			component.anchoredPosition = new Vector2(0f, 0f);
			return go;
		}

		internal static GameObject SetMiddleRight(this GameObject go)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(1f, 0.5f);
			component.anchorMin = new Vector2(1f, 0.5f);
			component.pivot = new Vector2(1f, 0.5f);
			component.anchoredPosition = new Vector2(0f, 0f);
			return go;
		}

		internal static GameObject SetBottomRight(this GameObject go)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(1f, 0f);
			component.anchorMin = new Vector2(1f, 0f);
			component.pivot = new Vector2(1f, 0f);
			component.anchoredPosition = new Vector2(0f, 0f);
			return go;
		}

		internal static GameObject SetUpperCenter(this GameObject go)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(0.5f, 1f);
			component.anchorMin = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, 0f);
			return go;
		}

		internal static GameObject SetMiddleCenter(this GameObject go)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = new Vector2(0f, 0f);
			return go;
		}

		internal static GameObject SetBottomCenter(this GameObject go)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(0.5f, 0f);
			component.anchorMin = new Vector2(0.5f, 0f);
			component.pivot = new Vector2(0.5f, 0f);
			component.anchoredPosition = new Vector2(0f, 0f);
			return go;
		}

		internal static GameObject SetSize(this GameObject go, float width, float height)
		{
			RectTransform component = go.GetComponent<RectTransform>();
			component.SetSizeWithCurrentAnchors((Axis)0, width);
			component.SetSizeWithCurrentAnchors((Axis)1, height);
			return go;
		}

		internal static GameObject SetWidth(this GameObject go, float width)
		{
			RectTransform component = go.GetComponent<RectTransform>();
			component.SetSizeWithCurrentAnchors((Axis)0, width);
			return go;
		}

		internal static GameObject SetHeight(this GameObject go, float height)
		{
			RectTransform component = go.GetComponent<RectTransform>();
			component.SetSizeWithCurrentAnchors((Axis)1, height);
			return go;
		}

		internal static float GetWidth(this GameObject go)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			Rect rect = component.rect;
			return ((Rect)(ref rect)).width;
		}

		internal static float GetHeight(this GameObject go)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			Rect rect = component.rect;
			return ((Rect)(ref rect)).height;
		}

		internal static float GetTextHeight(this GameObject go)
		{
			return go.GetComponent<Text>().preferredHeight;
		}

		internal static GameObject SetText(this GameObject go, string text)
		{
			Text component = go.GetComponent<Text>();
			if ((Object)(object)component != (Object)null)
			{
				component.text = text;
			}
			TMP_Text component2 = go.GetComponent<TMP_Text>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.text = text;
			}
			return go;
		}
	}
	public static class GameObjectExtension
	{
		public static bool IsValid(this GameObject self)
		{
			string text = ((Object)self).name;
			if (text.IndexOf('(') > 0)
			{
				text = text.Substring(((Object)self).name.IndexOf('(')).Trim();
			}
			if (string.IsNullOrEmpty(text))
			{
				Logger.LogError("GameObject must have a name!");
				return false;
			}
			if (Object.op_Implicit((Object)(object)self.GetComponent<ZNetView>()) && ((Object)self).name.IndexOfAny(new char[2] { ')', ' ' }) > 0)
			{
				Logger.LogError("GameObject name '" + ((Object)self).name + "' must not contain parenthesis or spaces!");
				return false;
			}
			return true;
		}
	}
	public static class ItemDropExtension
	{
		public static string TokenName(this ItemDrop self)
		{
			return self.m_itemData.m_shared.m_name;
		}
	}
	public static class ItemDataExtension
	{
		public static string TokenName(this ItemData self)
		{
			return self.m_shared.m_name;
		}
	}
	public static class RecipeExtension
	{
		public static bool IsValid(this Recipe self)
		{
			try
			{
				string text = ((Object)self).name;
				if (text.IndexOf('(') > 0)
				{
					text = text.Substring(((Object)self).name.IndexOf('(')).Trim();
				}
				if (string.IsNullOrEmpty(text))
				{
					throw new Exception("Recipe must have a name !");
				}
				return true;
			}
			catch (Exception data)
			{
				Logger.LogError(data);
				return false;
			}
		}
	}
	public static class PieceExtension
	{
		public static string TokenName(this Piece self)
		{
			return self.m_name;
		}
	}
	public static class StatusEffectExtension
	{
		public static string TokenName(this StatusEffect self)
		{
			return self.m_name;
		}

		public static bool IsValid(this StatusEffect self)
		{
			try
			{
				string text = ((Object)self).name;
				if (text.IndexOf('(') > 0)
				{
					text = text.Substring(((Object)self).name.IndexOf('(')).Trim();
				}
				if (string.IsNullOrEmpty(text))
				{
					throw new Exception("StatusEffect must have a name !");
				}
				return true;
			}
			catch (Exception data)
			{
				Logger.LogError(data);
				return false;
			}
		}
	}
	public static class PrefabExtension
	{
		public static void FixReferences(this object objectToFix)
		{
			MockResolveFailure.MockResolveFailures.Clear();
			MockManager.FixReferences(objectToFix, 0);
			Object val = (Object)((objectToFix is Object) ? objectToFix : null);
			string prefabName = (Object.op_Implicit(val) ? val.name : objectToFix.ToString());
			MockResolveFailure.PrintMockResolveFailures(prefabName);
		}

		public static void FixReferences(this GameObject gameObject)
		{
			MockResolveFailure.MockResolveFailures.Clear();
			gameObject.FixReferencesInternal(recursive: false);
			string prefabName = (Object.op_Implicit((Object)(object)gameObject) ? ((Object)gameObject).name : string.Empty);
			MockResolveFailure.PrintMockResolveFailures(prefabName);
		}

		public static void FixReferences(this GameObject gameObject, bool recursive)
		{
			MockResolveFailure.MockResolveFailures.Clear();
			gameObject.FixReferencesInternal(recursive);
			string prefabName = (Object.op_Implicit((Object)(object)gameObject) ? ((Object)gameObject).name : string.Empty);
			MockResolveFailure.PrintMockResolveFailures(prefabName);
		}

		private static void FixReferencesInternal(this GameObject gameObject, bool recursive)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			Component[] components = gameObject.GetComponents<Component>();
			foreach (Component val in components)
			{
				if (!(val is Transform))
				{
					MockManager.FixReferences(val, 0);
				}
			}
			if (!recursive)
			{
				return;
			}
			List<Tuple<Transform, GameObject>> list = new List<Tuple<Transform, GameObject>>();
			foreach (Transform item in gameObject.transform)
			{
				Transform val2 = item;
				GameObject realPrefabFromMock = MockManager.GetRealPrefabFromMock<GameObject>((Object)(object)((Component)val2).gameObject);
				if (Object.op_Implicit((Object)(object)realPrefabFromMock))
				{
					list.Add(new Tuple<Transform, GameObject>(val2, realPrefabFromMock));
				}
				else
				{
					((Component)val2).gameObject.FixReferencesInternal(recursive: true);
				}
			}
			foreach (Tuple<Transform, GameObject> item2 in list)
			{
				MockManager.ReplaceMockGameObject(item2.Item1, item2.Item2, gameObject);
			}
		}

		public static void CloneFields(this GameObject gameObject, GameObject objectToClone)
		{
			Dictionary<FieldInfo, object> dictionary = new Dictionary<FieldInfo, object>();
			Component[] componentsInChildren = objectToClone.GetComponentsInChildren<Component>();
			Component[] array = componentsInChildren;
			foreach (Component val in array)
			{
				FieldInfo[] fields = ((object)val).GetType().GetFields((BindingFlags)(-1));
				foreach (FieldInfo fieldInfo in fields)
				{
					if (!fieldInfo.IsLiteral && !fieldInfo.IsInitOnly)
					{
						dictionary.Add(fieldInfo, fieldInfo.GetValue(val));
					}
				}
				if (!Object.op_Implicit((Object)(object)gameObject.GetComponent(((object)val).GetType())))
				{
					gameObject.AddComponent(((object)val).GetType());
				}
			}
			Component[] componentsInChildren2 = gameObject.GetComponentsInChildren<Component>();
			Component[] array2 = componentsInChildren2;
			foreach (Component val2 in array2)
			{
				FieldInfo[] fields2 = ((object)val2).GetType().GetFields((BindingFlags)(-1));
				foreach (FieldInfo fieldInfo2 in fields2)
				{
					if (dictionary.TryGetValue(fieldInfo2, out var value))
					{
						fieldInfo2.SetValue(val2, value);
					}
				}
			}
		}
	}
	internal static class ObjectExtension
	{
		public static string GetObjectString(this object obj)
		{
			if (obj == null)
			{
				return "null";
			}
			string text = $"{obj}";
			Type type = obj.GetType();
			IEnumerable<FieldInfo> enumerable = from f in type.GetFields()
				where f.IsPublic
				select f;
			foreach (FieldInfo item in enumerable)
			{
				object value = item.GetValue(obj);
				string text2 = ((value == null) ? "null" : value.ToString());
				text = text + "\n " + item.Name + ": " + text2;
			}
			PropertyInfo[] properties = type.GetProperties();
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				object value2 = propertyInfo.GetValue(obj, null);
				string text3 = ((value2 == null) ? "null" : value2.ToString());
				text = text + "\n " + propertyInfo.Name + ": " + text3;
			}
			return text;
		}
	}
	public static class RectTransformExtensions
	{
		public static bool Overlaps(this RectTransform a, RectTransform b)
		{
			//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_000a: Unknown result type (might be due to invalid IL or missing references)
			Rect val = a.WorldRect();
			return ((Rect)(ref val)).Overlaps(b.WorldRect());
		}

		public static bool Overlaps(this RectTransform a, RectTransform b, bool allowInverse)
		{
			//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_000a: Unknown result type (might be due to invalid IL or missing references)
			Rect val = a.WorldRect();
			return ((Rect)(ref val)).Overlaps(b.WorldRect(), allowInverse);
		}

		public static Rect WorldRect(this RectTransform rectTransform)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Vector2 sizeDelta = rectTransform.sizeDelta;
			float num = sizeDelta.x * ((Transform)rectTransform).lossyScale.x;
			float num2 = sizeDelta.y * ((Transform)rectTransform).lossyScale.y;
			Vector3 position = ((Transform)rectTransform).position;
			return new Rect(position.x - num / 2f, position.y - num2 / 2f, num, num2);
		}
	}
	public static class ZNetExtension
	{
		public enum ZNetInstanceType
		{
			Local,
			Client,
			Server
		}

		public static bool IsLocalInstance(this ZNet znet)
		{
			if (znet.IsServer())
			{
				return !znet.IsDedicated();
			}
			return false;
		}

		public static bool IsClientInstance(this ZNet znet)
		{
			if (!znet.IsServer())
			{
				return !znet.IsDedicated();
			}
			return false;
		}

		public static bool IsServerInstance(this ZNet znet)
		{
			if (znet.IsServer())
			{
				return znet.IsDedicated();
			}
			return false;
		}

		public static ZNetInstanceType GetInstanceType(this ZNet znet)
		{
			if (znet.IsLocalInstance())
			{
				return ZNetInstanceType.Local;
			}
			if (znet.IsClientInstance())
			{
				return ZNetInstanceType.Client;
			}
			return ZNetInstanceType.Server;
		}

		public static bool IsAdmin(this ZNet znet, long uid)
		{
			if (!Object.op_Implicit((Object)(object)znet))
			{
				Logger.LogWarning("IsAdmin check failed: ZNet is null");
				return false;
			}
			if (znet.m_adminList == null)
			{
				Logger.LogWarning("IsAdmin check failed: admin list is only available on the server");
				return false;
			}
			ZNetPeer peer = znet.GetPeer(uid);
			if (peer == null)
			{
				Logger.LogWarning($"IsAdmin check failed: peer not found with id {uid}");
				return false;
			}
			string hostName = peer.m_socket.GetHostName();
			if (!string.IsNullOrEmpty(hostName))
			{
				return znet.ListContainsId(znet.m_adminList, hostName);
			}
			return false;
		}
	}
	internal interface IManager
	{
		void Init();
	}
	public class Logger
	{
		public static bool ShowDate = false;

		private static Logger instance = new Logger();

		private readonly Dictionary<string, ManualLogSource> logger = new Dictionary<string, ManualLogSource>();

		internal static void Destroy()
		{
			LogDebug("Destroying Logger");
			foreach (KeyValuePair<string, ManualLogSource> item in instance.logger)
			{
				Logger.Sources.Remove((ILogSource)(object)item.Value);
			}
			instance.logger.Clear();
		}

		private ManualLogSource GetLogger()
		{
			Type declaringType = new StackFrame(3).GetMethod().DeclaringType;
			if (!logger.TryGetValue(declaringType.FullName, out var value))
			{
				value = Logger.CreateLogSource(declaringType.FullName);
				logger.Add(declaringType.FullName, value);
			}
			return value;
		}

		private static void Log(LogLevel level, BepInPlugin sourceMod, object data)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			string text = string.Empty;
			if (ShowDate)
			{
				text = text + "[" + DateTime.Now.ToString(DateTimeFormatInfo.InvariantInfo) + "] ";
			}
			if (sourceMod != null)
			{
				text = text + "[" + sourceMod.Name + "] ";
			}
			instance.GetLogger().Log(level, (object)$"{text}{data}");
		}

		public static void LogFatal(object data)
		{
			Log((LogLevel)1, null, data);
		}

		public static void LogFatal(BepInPlugin sourceMod, object data)
		{
			Log((LogLevel)1, sourceMod, data);
		}

		public static void LogError(object data)
		{
			Log((LogLevel)2, null, data);
		}

		public static void LogError(BepInPlugin sourceMod, object data)
		{
			Log((LogLevel)2, sourceMod, data);
		}

		public static void LogWarning(object data)
		{
			Log((LogLevel)4, null, data);
		}

		public static void LogWarning(BepInPlugin sourceMod, object data)
		{
			Log((LogLevel)4, sourceMod, data);
		}

		public static void LogMessage(object data)
		{
			Log((LogLevel)8, null, data);
		}

		public static void LogMessage(BepInPlugin sourceMod, object data)
		{
			Log((LogLevel)8, sourceMod, data);
		}

		public static void LogInfo(object data)
		{
			Log((LogLevel)16, null, data);
		}

		public static void LogInfo(BepInPlugin sourceMod, object data)
		{
			Log((LogLevel)16, sourceMod, data);
		}

		public static void LogDebug(object data)
		{
			Log((LogLevel)32, null, data);
		}

		public static void LogDebug(BepInPlugin sourceMod, object data)
		{
			Log((LogLevel)32, sourceMod, data);
		}
	}
	[BepInPlugin("com.jotunn.jotunn", "Jotunn", "2.29.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(CompatibilityLevel.VersionCheckOnly, VersionStrictness.Patch)]
	public class Main : BaseUnityPlugin
	{
		public const string Version = "2.29.1";

		public const string ModName = "Jotunn";

		public const string ModGuid = "com.jotunn.jotunn";

		internal static Main Instance;

		internal static Harmony Harmony = new Harmony("com.jotunn.jotunn");

		private static GameObject rootObject;

		internal static GameObject RootObject => GetRootObject();

		private void Awake()
		{
			Instance = this;
			GetRootObject();
			ModCompatibility.Init();
			((IManager)SynchronizationManager.Instance).Init();
			Runtime.MakeAllAssetsLoadable();
			Game.isModded = true;
		}

		private void Start()
		{
			PatchInit.InitializePatches();
			AutomaticLocalizationsLoading.Init();
		}

		private void OnApplicationQuit()
		{
			AssetBundle.UnloadAllAssetBundles(false);
		}

		private static GameObject GetRootObject()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)rootObject))
			{
				return rootObject;
			}
			rootObject = new GameObject("_JotunnRoot");
			Object.DontDestroyOnLoad((Object)(object)rootObject);
			return rootObject;
		}

		internal static void LogInit(string module)
		{
			Logger.LogInfo("Initializing " + module);
			if (!Object.op_Implicit((Object)(object)Instance))
			{
				string data = module + " was accessed before Jotunn Awake, this can cause unexpected behaviour. Please make sure to add `[BepInDependency(Jotunn.Main.ModGuid)]` next to your BaseUnityPlugin";
				Logger.LogWarning(BepInExUtils.GetSourceModMetadata(), data);
			}
		}
	}
	internal class ClassMember
	{
		private static readonly Dictionary<Type, ClassMember> CachedClassMembers = new Dictionary<Type, ClassMember>();

		public List<MemberBase> Members { get; private set; } = new List<MemberBase>();

		public Type Type { get; private set; }

		private ClassMember(Type type, IEnumerable<FieldInfo> fieldInfos, IEnumerable<PropertyInfo> propertyInfos)
		{
			Type = type;
			foreach (FieldInfo fieldInfo in fieldInfos)
			{
				AddMember(new FieldMember(fieldInfo));
			}
			foreach (PropertyInfo propertyInfo in propertyInfos)
			{
				AddMember(new PropertyMember(propertyInfo));
			}
		}

		private void AddMember(MemberBase member)
		{
			if (member.IsClass && !(member.MemberType == typeof(string)) && (!(member.EnumeratedType != null) || (member.IsEnumeratedClass && !(member.EnumeratedType == typeof(string)))) && !member.HasCustomAttribute<NonSerializedAttribute>())
			{
				Members.Add(member);
			}
		}

		private static T[] GetMembersFromType<T>(Type type, Func<Type, T[]> getMembers)
		{
			T[] array = getMembers(type);
			Type baseType = type.BaseType;
			while (baseType != null)
			{
				T[] second = getMembers(baseType);
				array = array.Union(second).ToArray();
				baseType = baseType.BaseType;
			}
			return array;
		}

		public static ClassMember GetClassMember(Type type)
		{
			if (CachedClassMembers.TryGetValue(type, out var value))
			{
				return value;
			}
			FieldInfo[] membersFromType = GetMembersFromType(type, (Type t) => t.GetFields(~BindingFlags.Static));
			PropertyInfo[] membersFromType2 = GetMembersFromType(type, (Type t) => t.GetProperties(~BindingFlags.Static));
			value = new ClassMember(type, membersFromType, membersFromType2);
			CachedClassMembers[type] = value;
			return value;
		}
	}
	internal class FieldMember : MemberBase
	{
		private readonly FieldInfo fieldInfo;

		public FieldMember(FieldInfo fieldInfo)
		{
			this.fieldInfo = fieldInfo;
			base.MemberType = fieldInfo.FieldType;
			base.IsUnityObject = base.MemberType.IsSameOrSubclass(typeof(Object));
			base.IsClass = base.MemberType.IsClass;
			base.HasGetMethod = true;
			base.HasSetMethod = true;
			base.EnumeratedType = base.MemberType.GetEnumeratedType();
			base.IsEnumerableOfUnityObjects = base.EnumeratedType?.IsSameOrSubclass(typeof(Object)) ?? false;
			base.IsEnumeratedClass = base.EnumeratedType?.IsClass ?? false;
		}

		public override object GetValue(object obj)
		{
			try
			{
				return fieldInfo.GetValue(obj);
			}
			catch
			{
				return null;
			}
		}

		public override void SetValue(object obj, object value)
		{
			fieldInfo.SetValue(obj, value);
		}

		public override bool HasCustomAttribute<T>()
		{
			return fieldInfo.GetCustomAttribute<T>() != null;
		}
	}
	internal abstract class MemberBase
	{
		public bool HasGetMethod { get; protected set; }

		public bool HasSetMethod { get; protected set; }

		public Type MemberType { get; protected set; }

		public Type EnumeratedType { get; protected set; }

		public bool IsUnityObject { get; protected set; }

		public bool IsClass { get; protected set; }

		public bool IsEnumerableOfUnityObjects { get; protected set; }

		public bool IsEnumeratedClass { get; protected set; }

		public abstract object GetValue(object obj);

		public abstract void SetValue(object obj, object value);

		public abstract bool HasCustomAttribute<T>() where T : Attribute;
	}
	public class MockResolveFailure
	{
		public static List<MockResolveFailure> MockResolveFailures { get; } = new List<MockResolveFailure>();

		public string Message { get; private set; }

		public string FailedMockName { get; private set; }

		public string FailedMockPath { get; private set; }

		public Type MockType { get; private set; }

		public MockResolveFailure(string message, string failedMockName, string failedMockPath, Type mockType)
		{
			Message = message;
			FailedMockName = failedMockName;
			FailedMockPath = failedMockPath;
			MockType = mockType;
		}

		public MockResolveFailure(string message, string failedMockName, IEnumerable<string> failedMockPath, Type mockType)
		{
			Message = message;
			FailedMockName = failedMockName;
			FailedMockPath = string.Join<string>("->", failedMockPath);
			MockType = mockType;
		}

		private string ConstructMessage()
		{
			if (string.IsNullOrEmpty(FailedMockPath))
			{
				return ("Mock '" + FailedMockName + "' " + MockType.Name + " could not be resolved. " + Message).Trim();
			}
			return ("Mock " + MockType.Name + " at '" + FailedMockName + "' with child path '" + FailedMockPath + "' could not be resolved. " + Message).Trim();
		}

		public static void PrintMockResolveFailures(string prefabName)
		{
			if (MockResolveFailures.Count == 0)
			{
				return;
			}
			BepInPlugin sourceMod = ModQuery.GetPrefab(prefabName)?.SourceMod;
			int num = Math.Min(5, MockResolveFailures.Count);
			string arg = (string.IsNullOrEmpty(prefabName) ? "" : ("for '" + prefabName + "'"));
			string arg2 = ((MockResolveFailures.Count > num) ? $"(logging first {num} issues)" : "");
			Logger.LogWarning(sourceMod, $"{MockResolveFailures.Count} mocks {arg} could not be resolved. {arg2}".Replace("  ", " ").Trim());
			foreach (MockResolveFailure item in MockResolveFailures.GetRange(0, num))
			{
				Logger.LogWarning(sourceMod, item.ConstructMessage());
			}
		}
	}
	internal class PropertyMember : MemberBase
	{
		private readonly PropertyInfo propertyInfo;

		public PropertyMember(PropertyInfo propertyInfo)
		{
			this.propertyInfo = propertyInfo;
			base.MemberType = propertyInfo.PropertyType;
			base.IsUnityObject = base.MemberType.IsSameOrSubclass(typeof(Object));
			base.IsClass = base.MemberType.IsClass;
			base.HasGetMethod = propertyInfo.GetIndexParameters().Length == 0 && propertyInfo.GetMethod != null;
			base.HasSetMethod = propertyInfo.SetMethod != null;
			base.EnumeratedType = base.MemberType.GetEnumeratedType();
			base.IsEnumerableOfUnityObjects = base.EnumeratedType?.IsSameOrSubclass(typeof(Object)) ?? false;
			base.IsEnumeratedClass = base.EnumeratedType?.IsClass ?? false;
		}

		public override object GetValue(object obj)
		{
			try
			{
				return propertyInfo.GetValue(obj);
			}
			catch
			{
				return null;
			}
		}

		public override void SetValue(object obj, object value)
		{
			propertyInfo.SetValue(obj, value);
		}

		public override bool HasCustomAttribute<T>()
		{
			return propertyInfo.GetCustomAttribute<T>() != null;
		}
	}
}
namespace Jotunn.Utils
{
	public static class AssetUtils
	{
		public const char AssetBundlePathSeparator = '$';

		private static MethodInfo LoadImageMethod { get; } = AccessTools.Method(typeof(ImageConversion), "LoadImage", new Type[2]
		{
			typeof(Texture2D),
			typeof(byte[])
		}, (Type[])null);

		public static Texture2D LoadTexture(string texturePath, bool relativePath = true)
		{
			string text = texturePath;
			if (relativePath)
			{
				text = Path.Combine(Paths.PluginPath, texturePath);
			}
			if (!File.Exists(text))
			{
				return null;
			}
			if (!text.EndsWith(".png") && !text.EndsWith(".jpg"))
			{
				throw new Exception("LoadTexture can only load png or jpg textures");
			}
			byte[] data = File.ReadAllBytes(text);
			return LoadImage(data);
		}

		public static Texture2D LoadImage(byte[] data)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			Texture2D val = new Texture2D(2, 2);
			if (!LoadImage(val, data))
			{
				return null;
			}
			return val;
		}

		public static bool LoadImage(Texture2D texture, byte[] data)
		{
			return (bool)LoadImageMethod.Invoke(null, new object[2] { texture, data });
		}

		public static Texture2D DuplicateTexture(Texture2D texture, Rect textureRect)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)texture))
			{
				return null;
			}
			int num = (int)((Rect)(ref textureRect)).width;
			int num2 = (int)((Rect)(ref textureRect)).height;
			int num3 = (int)((Rect)(ref textureRect)).x;
			int num4 = (int)((Rect)(ref textureRect)).y;
			RenderTexture active = RenderTexture.active;
			RenderTexture temporary = RenderTexture.GetTemporary(((Texture)texture).width, ((Texture)texture).height, 0, (RenderTextureFormat)7, (RenderTextureReadWrite)2);
			Graphics.Blit((Texture)(object)texture, temporary);
			RenderTexture.active = temporary;
			Texture2D val = new Texture2D(num, num2);
			val.ReadPixels(new Rect((float)num3, (float)num4, (float)num, (float)num2), 0, 0);
			val.Apply();
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(temporary);
			return val;
		}

		public static Texture2D DuplicateTexture(Texture2D texture)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			return DuplicateTexture(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height));
		}

		public static Texture2D DuplicateTexture(Sprite sprite)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return DuplicateTexture(sprite.texture, sprite.textureRect);
		}

		public static Sprite DuplicateSprite(Sprite sprite)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = DuplicateTexture(sprite);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}

		public static Sprite LoadSpriteFromFile(string spritePath)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return LoadSpriteFromFile(spritePath, Vector2.zero);
		}

		public static Sprite LoadSpriteFromFile(string spritePath, Vector2 pivot)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = LoadTexture(spritePath);
			if ((Object)(object)val != (Object)null)
			{
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), pivot);
			}
			return null;
		}

		public static Mesh LoadMesh(string meshPath)
		{
			string text = Path.Combine(Paths.PluginPath, meshPath);
			if (!File.Exists(text))
			{
				return null;
			}
			return ObjImporter.ImportFile(text);
		}

		public static AssetBundle LoadAssetBundle(string bundlePath)
		{
			string text = Path.Combine(Paths.PluginPath, bundlePath);
			if (!File.Exists(text))
			{
				return null;
			}
			return AssetBundle.LoadFromFile(text);
		}

		public static AssetBundle LoadAssetBundleFromResources(string bundleName, Assembly resourceAssembly)
		{
			if (resourceAssembly == null)
			{
				throw new ArgumentNullException("Parameter resourceAssembly can not be null.");
			}
			string text = null;
			try
			{
				text = resourceAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(bundleName));
			}
			catch (Exception)
			{
			}
			if (text == null)
			{
				Logger.LogError("AssetBundle " + bundleName + " not found in assembly manifest");
				return null;
			}
			using Stream stream = resourceAssembly.GetManifestResourceStream(text);
			return AssetBundle.LoadFromStream(stream);
		}

		public static AssetBundle LoadAssetBundleFromResources(string bundleName)
		{
			return LoadAssetBundleFromResources(bundleName, ReflectionHelper.GetCallingAssembly());
		}

		public static string LoadTextFromResources(string fileName, Assembly resourceAssembly)
		{
			if (resourceAssembly == null)
			{
				throw new ArgumentNullException("Parameter resourceAssembly can not be null.");
			}
			string text = null;
			try
			{
				text = resourceAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(fileName));
			}
			catch (Exception)
			{
			}
			if (text == null)
			{
				Logger.LogError("File " + fileName + " not found in assembly manifest");
				return null;
			}
			using Stream stream = resourceAssembly.GetManifestResourceStream(text);
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}

		public static string LoadTextFromResources(string fileName)
		{
			return LoadTextFromResources(fileName, ReflectionHelper.GetCallingAssembly());
		}

		public static string LoadText(string path)
		{
			string text = Path.Combine(Paths.PluginPath, path);
			if (!File.Exists(text))
			{
				Logger.LogError("Error, failed to load contents from non-existant path: $" + text);
				return null;
			}
			return File.ReadAllText(text);
		}

		public static Sprite LoadSprite(string assetPath)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.Combine(Paths.PluginPath, assetPath);
			if (!File.Exists(text))
			{
				return null;
			}
			if (text.Contains('$'.ToString()))
			{
				string[] array = text.Split(new char[1] { '$' });
				string text2 = array[0];
				string text3 = array[1];
				AssetBundle val = AssetBundle.LoadFromFile(text2);
				Sprite result = val.LoadAsset<Sprite>(text3);
				val.Unload(false);
				return result;
			}
			Texture2D val2 = LoadTexture(text, relativePath: false);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				return null;
			}
			return Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), Vector2.zero);
		}

		internal static bool TryLoadPrefab(BepInPlugin sourceMod, AssetBundle assetBundle, string assetName, out GameObject prefab)
		{
			try
			{
				prefab = assetBundle.LoadAsset<GameObject>(assetName);
			}
			catch (Exception arg)
			{
				prefab = null;
				Logger.LogError(sourceMod, $"Failed to load prefab '{assetName}' from AssetBundle {assetBundle}:\n{arg}");
				return false;
			}
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				Logger.LogError(sourceMod, $"Failed to load prefab '{assetName}' from AssetBundle {assetBundle}");
				return false;
			}
			return true;
		}
	}
	internal static class AutomaticLocalizationsLoading
	{
		public const string TranslationsFolderName = "Translations";

		public const string CommunityTranslationFileName = "community_translation.json";

		public static void Init()
		{
			HashSet<FileInfo> hashSet = new HashSet<FileInfo>();
			HashSet<FileInfo> hashSet2 = new HashSet<FileInfo>();
			HashSet<FileInfo> hashSet3 = new HashSet<FileInfo>();
			foreach (FileInfo translationFile in GetTranslationFiles(Paths.LanguageTranslationsFolder, "community_translation.json"))
			{
				hashSet.Add(translationFile);
			}
			foreach (FileInfo translationFile2 in GetTranslationFiles(Paths.LanguageTranslationsFolder, "*.json"))
			{
				hashSet.Add(translationFile2);
			}
			foreach (FileInfo translationFile3 in GetTranslationFiles(Paths.LanguageTranslationsFolder, "*.language"))
			{
				hashSet2.Add(translationFile3);
			}
			foreach (FileInfo translationFile4 in GetTranslationFiles(Paths.LanguageTranslationsFolder, "*.yaml"))
			{
				hashSet3.Add(translationFile4);
			}
			foreach (FileInfo translationFile5 in GetTranslationFiles(Paths.LanguageTranslationsFolder, "*.yml"))
			{
				hashSet3.Add(translationFile5);
			}
			foreach (FileInfo item in hashSet)
			{
				try
				{
					PluginInfo pluginInfoFromPath = BepInExUtils.GetPluginInfoFromPath(item);
					BepInPlugin val = ((pluginInfoFromPath != null) ? pluginInfoFromPath.Metadata : null);
					LocalizationManager.Instance.GetLocalization(val ?? ((BaseUnityPlugin)Main.Instance).Info.Metadata).AddFileByPath(item.FullName, isJson: true);
				}
				catch (Exception arg)
				{
					Logger.LogWarning($"Exception caught while loading localization file {item}: {arg}");
				}
			}
			foreach (FileInfo item2 in hashSet2)
			{
				try
				{
					PluginInfo pluginInfoFromPath2 = BepInExUtils.GetPluginInfoFromPath(item2);
					BepInPlugin val2 = ((pluginInfoFromPath2 != null) ? pluginInfoFromPath2.Metadata : null);
					LocalizationManager.Instance.GetLocalization(val2 ?? ((BaseUnityPlugin)Main.Instance).Info.Metadata).AddFileByPath(item2.FullName);
				}
				catch (Exception arg2)
				{
					Logger.LogWarning($"Exception caught while loading localization file {item2}: {arg2}");
				}
			}
			if (hashSet3.Count > 0 && !CustomLocalization.IsYamlDotNetAvailable())
			{
				Logger.LogWarning($"Found {hashSet3.Count} YAML localization file(s) but YamlDotNet is not loaded. " + "Mods using .yaml/.yml localization must include YamlDotNet.dll as a dependency.");
				return;
			}
			foreach (FileInfo item3 in hashSet3)
			{
				try
				{
					PluginInfo pluginInfoFromPath3 = BepInExUtils.GetPluginInfoFromPath(item3);
					BepInPlugin val3 = ((pluginInfoFromPath3 != null) ? pluginInfoFromPath3.Metadata : null);
					LocalizationManager.Instance.GetLocalization(val3 ?? ((BaseUnityPlugin)Main.Instance).Info.Metadata).AddFileByPath(item3.FullName);
				}
				catch (Exception arg3)
				{
					Logger.LogWarning($"Exception caught while loading localization file {item3}: {arg3}");
				}
			}
		}

		private static IEnumerable<FileInfo> GetTranslationFiles(string path, string searchPattern)
		{
			return GetTranslationFiles(new DirectoryInfo(path), searchPattern);
		}

		private static IEnumerable<FileInfo> GetTranslationFiles(DirectoryInfo pathDirectoryInfo, string searchPattern)
		{
			if (!pathDirectoryInfo.Exists)
			{
				yield break;
			}
			string[] files = Directory.GetFiles(pathDirectoryInfo.FullName, searchPattern, SearchOption.AllDirectories);
			foreach (string item in files.Where((string path) => new DirectoryInfo(path).Parent?.Parent?.Name == "Translations"))
			{
				yield return new FileInfo(item);
			}
		}
	}
	public static class BepInExUtils
	{
		private static BaseUnityPlugin[] Plugins;

		private static Dictionary<PluginInfo, string> PluginInfoTypeNameCache { get; } = new Dictionary<PluginInfo, string>();

		private static Dictionary<Assembly, PluginInfo> AssemblyToPluginInfoCache { get; } = new Dictionary<Assembly, PluginInfo>();

		private static Dictionary<Type, PluginInfo> TypeToPluginInfoCache { get; } = new Dictionary<Type, PluginInfo>();

		private static BaseUnityPlugin[] CacheDependentPlugins()
		{
			List<BaseUnityPlugin> list = new List<BaseUnityPlugin>();
			foreach (BaseUnityPlugin loadedPlugin in GetLoadedPlugins())
			{
				if (loadedPlugin.Info == null)
				{
					Logger.LogWarning("Plugin without Info found: " + ((object)loadedPlugin).GetType().Assembly.FullName);
					continue;
				}
				if (loadedPlugin.Info.Metadata == null)
				{
					Logger.LogWarning("Plugin without Metadata found: " + ((object)loadedPlugin).GetType().Assembly.FullName);
					continue;
				}
				if (loadedPlugin.Info.Metadata.GUID == "com.jotunn.jotunn")
				{
					list.Add(loadedPlugin);
					continue;
				}
				foreach (BepInDependency item in ((object)loadedPlugin).GetType().GetCustomAttributes(typeof(BepInDependency), inherit: false).Cast<BepInDependency>())
				{
					if (item.DependencyGUID == "com.jotunn.jotunn")
					{
						list.Add(loadedPlugin);
					}
				}
			}
			return list.ToArray();
		}

		public static Dictionary<string, BaseUnityPlugin> GetDependentPlugins(bool includeJotunn = false)
		{
			if (Plugins == null)
			{
				if (!ReflectionHelper.GetPrivateField<bool>(typeof(Chainloader), "_loaded"))
				{
					return new Dictionary<string, BaseUnityPlugin>();
				}
				Plugins = CacheDependentPlugins();
			}
			return Plugins.Where((BaseUnityPlugin plugin) => includeJotunn || plugin.Info.Metadata.GUID != "com.jotunn.jotunn").ToDictionary((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID);
		}

		public static Dictionary<string, BaseUnityPlugin> GetPlugins(bool includeJotunn = false)
		{
			return (from plugin in GetLoadedPlugins()
				where includeJotunn || plugin.Info.Metadata.GUID != "com.jotunn.jotunn"
				select plugin).ToDictionary((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID);
		}

		public static PluginInfo GetPluginInfoFromType(Type type)
		{
			if (TypeToPluginInfoCache.TryGetValue(type, out var value))
			{
				return value;
			}
			foreach (PluginInfo value2 in Chainloader.PluginInfos.Values)
			{
				string privateProperty = ReflectionHelper.GetPrivateProperty<string>(value2, "TypeName");
				if (privateProperty.Equals(type.FullName))
				{
					TypeToPluginInfoCache[type] = value2;
					return value2;
				}
			}
			return null;
		}

		private static string GetPluginInfoTypeName(PluginInfo info)
		{
			if (PluginInfoTypeNameCache.TryGetValue(info, out var value))
			{
				return value;
			}
			value = ReflectionHelper.GetPrivateProperty<string>(info, "TypeName");
			PluginInfoTypeNameCache.Add(info, value);
			return value;
		}

		public static PluginInfo GetPluginInfoFromAssembly(Assembly assembly)
		{
			if (AssemblyToPluginInfoCache.TryGetValue(assembly, out var value))
			{
				return value;
			}
			foreach (PluginInfo value2 in Chainloader.PluginInfos.Values)
			{
				if (assembly.GetType(GetPluginInfoTypeName(value2)) != null)
				{
					AssemblyToPluginInfoCache[assembly] = value2;
					return value2;
				}
			}
			AssemblyToPluginInfoCache[assembly] = null;
			return null;
		}

		public static PluginInfo GetPluginInfoFromPath(FileInfo fileInfo)
		{
			return Chainloader.PluginInfos.Values.Where((PluginInfo pi) => pi.Location != null).FirstOrDefault((Func<PluginInfo, bool>)((PluginInfo pi) => fileInfo.DirectoryName != null && fileInfo.DirectoryName.Contains(new FileInfo(pi.Location).DirectoryName) && new FileInfo(pi.Location).DirectoryName != Paths.PluginPath));
		}

		public static BepInPlugin GetSourceModMetadata()
		{
			Type callingType = ReflectionHelper.GetCallingType();
			PluginInfo pluginInfoFromType = GetPluginInfoFromType(callingType);
			object obj = ((pluginInfoFromType != null) ? pluginInfoFromType.Metadata : null);
			if (obj == null)
			{
				PluginInfo pluginInfoFromAssembly = GetPluginInfoFromAssembly(callingType.Assembly);
				obj = ((pluginInfoFromAssembly != null) ? pluginInfoFromAssembly.Metadata : null) ?? ((BaseUnityPlugin)Main.Instance).Info.Metadata;
			}
			return (BepInPlugin)obj;
		}

		private static IEnumerable<BaseUnityPlugin> GetLoadedPlugins()
		{
			return from x in Chainloader.PluginInfos
				where x.Value != null && (Object)(object)x.Value.Instance != (Object)null
				select x.Value.Instance;
		}
	}
	public static class BoneReorder
	{
		private static bool applied;

		public static void ApplyOnEquipmentChanged()
		{
			if (!applied)
			{
				Main.Harmony.PatchAll(typeof(BoneReorder));
				applied = true;
			}
		}

		public static bool IsReorderingEnabled()
		{
			return applied;
		}

		[HarmonyPatch(typeof(VisEquipment), "SetLegEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetLegEquiped(VisEquipment __instance, int hash, ref bool __result)
		{
			if (__result && __instance.m_legItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_legItemInstances);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetHelmetEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetHelmetEquiped(VisEquipment __instance, int hash, int hairHash, ref bool __result)
		{
			if (__result && (Object)(object)__instance.m_helmetItemInstance != (Object)null)
			{
				ReorderBones(__instance, hash, new List<GameObject> { __instance.m_helmetItemInstance });
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetChestEquiped(VisEquipment __instance, int hash, ref bool __result)
		{
			if (__result && __instance.m_chestItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_chestItemInstances);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetShoulderEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetShoulderEquiped(VisEquipment __instance, int hash, int variant, ref bool __result)
		{
			if (__result && __instance.m_shoulderItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_shoulderItemInstances);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetUtilityEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetUtilityEquiped(VisEquipment __instance, int hash, ref bool __result)
		{
			if (__result && __instance.m_utilityItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_utilityItemInstances);
			}
		}

		private static void ReorderBones(VisEquipment visEquipment, int itemPrefabHash, List<GameObject> instancesToFix)
		{
			if (!((Object)(object)visEquipment != (Object)null))
			{
				return;
			}
			try
			{
				Transform val = ((Component)visEquipment).transform.Find("Visual/Armature/Hips");
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(itemPrefabHash);
				if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)itemPrefab))
				{
					Logger.LogDebug($"Prefab missing components. Skipping {itemPrefab} {val}");
					return;
				}
				Logger.LogDebug("Reordering bones");
				int childCount = itemPrefab.transform.childCount;
				int num = 0;
				for (int i = 0; i < childCount; i++)
				{
					Transform child = itemPrefab.transform.GetChild(i);
					if (((Object)child).name.StartsWith("attach_skin"))
					{
						int num2 = 0;
						SkinnedMeshRenderer[] componentsInChildren = instancesToFix[num].GetComponentsInChildren<SkinnedMeshRenderer>(true);
						SkinnedMeshRenderer[] componentsInChildren2 = ((Component)child).GetComponentsInChildren<SkinnedMeshRenderer>(true);
						foreach (SkinnedMeshRenderer skinnedMeshRenderer in componentsInChildren2)
						{
							SkinnedMeshRenderer skinnedMeshRenderer2 = componentsInChildren[num2];
							skinnedMeshRenderer2.SetBones(skinnedMeshRenderer.GetBoneNames(), val);
							num2++;
						}
						num++;
					}
				}
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"Exception caught while reordering bones: {arg}");
			}
		}

		private static void SetBones(this SkinnedMeshRenderer skinnedMeshRenderer, string[] boneNames, Transform skeletonRoot)
		{
			Transform[] array = (Transform[])(object)new Transform[skinnedMeshRenderer.bones.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = FindInChildren(skeletonRoot, boneNames[i]);
			}
			skinnedMeshRenderer.bones = array;
			skinnedMeshRenderer.rootBone = skeletonRoot;
		}

		private static string[] GetBoneNames(this SkinnedMeshRenderer skinnedMeshRenderer)
		{
			List<string> list = new List<string>();
			Transform[] bones = skinnedMeshRenderer.bones;
			foreach (Transform val in bones)
			{
				list.Add(((Object)val).name);
			}
			return list.ToArray();
		}

		private static Transform FindInChildren(Transform transform, string name)
		{
			if (((Object)transform).name == name)
			{
				return transform;
			}
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform val = FindInChildren(transform.GetChild(i), name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}
	}
	public class ConfigFileWatcher
	{
		private const long TICKS_PER_MILISEC = 10000L;

		private DateTime lastReadTime = DateTime.MinValue;

		private readonly ConfigFile configFile;

		private readonly BepInPlugin sourceMod;

		private readonly string configFileDir;

		private readonly string configFileName;

		private readonly long reloadDelay;

		public event Action OnConfigFileReloaded;

		public ConfigFileWatcher(ConfigFile configFile, long reloadDelay = 1000L)
		{
			PluginInfo pluginInfoFromAssembly = BepInExUtils.GetPluginInfoFromAssembly(Assembly.GetCallingAssembly());
			sourceMod = ((pluginInfoFromAssembly != null) ? pluginInfoFromAssembly.Metadata : null);
			if (sourceMod == null || sourceMod.GUID == ((BaseUnityPlugin)Main.Instance).Info.Metadata.GUID)
			{
				sourceMod = BepInExUtils.GetSourceModMetadata();
			}
			this.configFile = configFile;
			this.reloadDelay = reloadDelay * 10000;
			configFileDir = Directory.GetParent(configFile.ConfigFilePath).FullName;
			configFileName = Path.GetFileName(configFile.ConfigFilePath);
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(configFileDir, configFileName);
			fileSystemWatcher.Changed += ReloadConfigFile;
			fileSystemWatcher.Created += ReloadConfigFile;
			fileSystemWatcher.Renamed += ReloadConfigFile;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void InvokeOnConfigFileReloaded()
		{
			this.OnConfigFileReloaded?.SafeInvoke();
		}

		internal void ReloadConfigFile(object sender, FileSystemEventArgs eventArgs)
		{
			DateTime now = DateTime.Now;
			long num = now.Ticks - lastReadTime.Ticks;
			if (!File.Exists(configFile.ConfigFilePath) || num < reloadDelay)
			{
				return;
			}
			try
			{
				Logger.LogInfo(sourceMod, "Reloading " + configFileName);
				bool saveOnConfigSet = configFile.SetSaveOnConfigSet(saveOnConfigSet: false);
				configFile.Reload();
				configFile.SaveOnConfigSet = saveOnConfigSet;
				lastReadTime = now;
				InvokeOnConfigFileReloaded();
			}
			catch
			{
				Logger.LogError(sourceMod, "There was an issue loading " + configFileName);
				Logger.LogError(sourceMod, "Please check your config entries for spelling and format!");
			}
		}
	}
	public static class ConfigManagerUtils
	{
		private static PropertyInfo displayingWindowInfo;

		private static MethodInfo buildSettingListMethodInfo;

		public static BaseUnityPlugin Plugin { get; private set; }

		public static bool DisplayingWindow
		{
			get
			{
				if (Object.op_Implicit((Object)(object)Plugin))
				{
					return (bool)displayingWindowInfo.GetValue(Plugin);
				}
				return false;
			}
			set
			{
				displayingWindowInfo?.SetValue(Plugin, value);
			}
		}

		static ConfigManagerUtils()
		{
			if (Chainloader.PluginInfos.TryGetValue("com.bepis.bepinex.configurationmanager", out var value) && Object.op_Implicit((Object)(object)value.Instance))
			{
				Plugin = value.Instance;
				displayingWindowInfo = AccessTools.Property(((object)Plugin).GetType(), "DisplayingWindow");
				buildSettingListMethodInfo = AccessTools.Method(((object)Plugin).GetType(), "BuildSettingList", (Type[])null, (Type[])null);
			}
			else if (Chainloader.PluginInfos.TryGetValue("_shudnal.ConfigurationManager", out value) && Object.op_Implicit((Object)(object)value.Instance))
			{
				Plugin = value.Instance;
				displayingWindowInfo = AccessTools.Property(((object)Plugin).GetType(), "DisplayingWindow");
				buildSettingListMethodInfo = AccessTools.Method(((object)Plugin).GetType(), "BuildSettingList", (Type[])null, (Type[])null);
			}
		}

		public static void BuildSettingList()
		{
			if (Object.op_Implicit((Object)(object)Plugin))
			{
				buildSettingListMethodInfo.Invoke(Plugin, null);
			}
		}
	}
	public class ConfigurationSynchronizationEventArgs : EventArgs
	{
		public bool InitialSynchronization { get; set; }

		public HashSet<string> UpdatedPluginGUIDs { get; set; }
	}
	public class DungeonGeneratorTheme : MonoBehaviour
	{
		public string m_themeName = "";
	}
	internal class ExtEquipment : MonoBehaviour
	{
		private static bool Enabled;

		private static readonly Dictionary<VisEquipment, ExtEquipment> Instances = new Dictionary<VisEquipment, ExtEquipment>();

		private Humanoid MyHumanoid;

		private int NewRightItemVariant;

		private int CurrentRightItemVariant;

		private int NewRightBackItemVariant;

		private int CurrentRightBackItemVariant;

		private int NewChestVariant;

		private int CurrentChestVariant;

		public static void Enable()
		{
			if (!Enabled)
			{
				Enabled = true;
				Main.Harmony.PatchAll(typeof(ExtEquipment));
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "Awake")]
		[HarmonyPostfix]
		private static void VisEquipment_Awake(VisEquipment __instance)
		{
			ExtEquipment extEquipment = default(ExtEquipment);
			if (!((Component)__instance).gameObject.TryGetComponent<ExtEquipment>(ref extEquipment))
			{
				((Component)__instance).gameObject.AddComponent<ExtEquipment>();
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "UpdateEquipmentVisuals")]
		[HarmonyPrefix]
		private static void VisEquipment_UpdateEquipmentVisuals(VisEquipment __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance.m_nview))
			{
				ZDO zDO = __instance.m_nview.GetZDO();
				if (zDO != null && Instances.TryGetValue(__instance, out var value))
				{
					value.NewRightItemVariant = zDO.GetInt("RightItemVariant", 0);
					value.NewChestVariant = zDO.GetInt("ChestItemVariant", 0);
					value.NewRightBackItemVariant = zDO.GetInt("RightBackItemVariant", 0);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetRightHandEquipped")]
		[HarmonyILManipulator]
		private static void VisEquipment_SetRightHandEquiped(ILContext il)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			ExtEquipment instance = null;
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1)
			}))
			{
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<int, VisEquipment, int>>((Func<int, VisEquipment, int>)delegate(int hash, VisEquipment self)
				{
					if (Instances.TryGetValue(self, out instance) && hash != 0 && instance.CurrentRightItemVariant != instance.NewRightItemVariant)
					{
						instance.CurrentRightItemVariant = instance.NewRightItemVariant;
						return hash + instance.CurrentRightItemVariant;
					}
					return hash;
				});
			}
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 0)
			}))
			{
				val.EmitDelegate<Func<int, int>>((Func<int, int>)((int variant) => (!((Object)(object)instance != (Object)null)) ? variant : instance.CurrentRightItemVariant));
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetBackEquipped")]
		[HarmonyILManipulator]
		private static void VisEquipment_SetBackEquiped(ILContext il)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			ExtEquipment instance = null;
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 2)
			}))
			{
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<int, VisEquipment, int>>((Func<int, VisEquipment, int>)delegate(int hash, VisEquipment self)
				{
					if (Instances.TryGetValue(self, out instance) && hash != 0 && instance.CurrentRightBackItemVariant != instance.NewRightBackItemVariant)
					{
						instance.CurrentRightBackItemVariant = instance.NewRightBackItemVariant;
						return hash + instance.CurrentRightBackItemVariant;
					}
					return hash;
				});
			}
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 2),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 0)
			}))
			{
				val.EmitDelegate<Func<int, int>>((Func<int, int>)((int variant) => (!((Object)(object)instance != (Object)null)) ? variant : instance.CurrentRightBackItemVariant));
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped")]
		[HarmonyILManipulator]
		private static void VisEquipment_SetChestEquiped(ILContext il)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			ExtEquipment instance = null;
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1)
			}))
			{
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<int, VisEquipment, int>>((Func<int, VisEquipment, int>)delegate(int hash, VisEquipment self)
				{
					if (Instances.TryGetValue(self, out instance) && hash != 0 && instance.CurrentChestVariant != instance.NewChestVariant)
					{
						instance.CurrentChestVariant = instance.NewChestVariant;
						return hash + instance.CurrentChestVariant;
					}
					return hash;
				});
			}
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, -1)
			}))
			{
				val.EmitDelegate<Func<int, int>>((Func<int, int>)((int variant) => (!((Object)(object)instance != (Object)null)) ? variant : instance.CurrentChestVariant));
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetRightItem")]
		[HarmonyPrefix]
		private static void VisEquipment_SetRightItem(VisEquipment __instance, string name)
		{
			if (!Instances.TryGetValue(__instance, out var value) || !Object.op_Implicit((Object)(object)value.MyHumanoid) || value.MyHumanoid.m_rightItem == null || (__instance.m_rightItem == name && value.MyHumanoid.m_rightItem.m_variant == value.CurrentRightItemVariant))
			{
				return;
			}
			value.NewRightItemVariant = value.MyHumanoid.m_rightItem.m_variant;
			if (Object.op_Implicit((Object)(object)__instance.m_nview))
			{
				ZDO zDO = __instance.m_nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set("RightItemVariant", (!string.IsNullOrEmpty(name)) ? value.NewRightItemVariant : 0);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetRightBackItem")]
		[HarmonyPrefix]
		private static void VisEquipment_SetRightBackItem(VisEquipment __instance, string name)
		{
			if (!Instances.TryGetValue(__instance, out var value) || !Object.op_Implicit((Object)(object)value.MyHumanoid) || value.MyHumanoid.m_hiddenRightItem == null || (__instance.m_rightBackItem == name && value.MyHumanoid.m_hiddenRightItem.m_variant == value.CurrentRightBackItemVariant))
			{
				return;
			}
			value.NewRightBackItemVariant = value.MyHumanoid.m_hiddenRightItem.m_variant;
			if (Object.op_Implicit((Object)(object)__instance.m_nview))
			{
				ZDO zDO = __instance.m_nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set("RightBackItemVariant", (!string.IsNullOrEmpty(name)) ? value.NewRightBackItemVariant : 0);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetChestItem")]
		[HarmonyPrefix]
		private static void VisEquipment_SetChestItem(VisEquipment __instance, string name)
		{
			if (!Instances.TryGetValue(__instance, out var value) || !Object.op_Implicit((Object)(object)value.MyHumanoid) || value.MyHumanoid.m_chestItem == null || (__instance.m_chestItem == name && value.MyHumanoid.m_chestItem.m_variant == value.CurrentChestVariant))
			{
				return;
			}
			value.NewChestVariant = value.MyHumanoid.m_chestItem.m_variant;
			if (Object.op_Implicit((Object)(object)__instance.m_nview))
			{
				ZDO zDO = __instance.m_nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set("ChestItemVariant", (!string.IsNullOrEmpty(name)) ? value.NewChestVariant : 0);
				}
			}
		}

		private void Awake()
		{
			MyHumanoid = ((Component)this).gameObject.GetComponent<Humanoid>();
			Instances.Add(((Component)this).gameObject.GetComponent<VisEquipment>(), this);
		}

		private void OnDestroy()
		{
			Instances.Remove(((Component)this).gameObject.GetComponent<VisEquipment>());
		}
	}
	public static class GameConstants
	{
		public static class GlobalKey
		{
			public static readonly string None = "";

			public static readonly string KilledBonemass = "defeated_bonemass";

			public static readonly string KilledElder = "defeated_gdking";

			public static readonly string KilledYagluth = "defeated_goblinking";

			public static readonly string KilledModer = "defeated_dragon";

			public static readonly string KilledEikthyr = "defeated_eikthyr";

			public static readonly string KilledTroll = "KilledTroll";

			public static readonly string KilledSurtling = "killed_surtling";
		}

		public static class Weather
		{
			public static readonly string ClearSkies = "Clear";

			public static readonly string MeadowsClearSkies = "Heath_clear";

			public static readonly string LightRain = "LightRain";

			public static readonly string Rain = "Rain";

			public static readonly string ThunderStorm = "ThunderStorm";

			public static readonly string ClearThunderStorm = "nofogts";

			public static readonly string SwampRain = "SwampRain";

			public static readonly string MistlandsDark = "Darklands_dark";

			public static readonly string AshlandsAshrain = "Ashrain";

			public static readonly string MountainSnow = "Snow";

			public static readonly string MountainBlizzard = "SnowStorm";

			public static readonly string BlackForestFog = "DeepForest Mist";

			public static readonly string Fog = "Misty";

			public static readonly string DeepNorthSnow = "Twilight_Snow";

			public static readonly string DeepNorthSnowStorm = "Twilight_SnowStorm";

			public static readonly string DeepNorthClear = "Twilight_Clear";

			public static readonly string EikthyrsThunderstorm = "Eikthyr";

			public static readonly string EldersHaze = "GDKing";

			public static readonly string BonemassDownpour = "Bonemass";

			public static readonly string ModersVortex = "Moder";

			public static readonly string YagluthsMagicBlizzard = "GoblinKing";

			public static readonly string Crypt = "Crypt";

			public static readonly string SunkenCrypt = "SunkenCrypt";
		}
	}
	public static class GameVersions
	{
		public static Version ValheimVersion { get; } = GetValheimVersion();

		public static uint NetworkVersion { get; } = GetNetworkVersion();

		private static Version GetValheimVersion()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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)
			return new Version(Version.CurrentVersion.m_major, Version.CurrentVersion.m_minor, Version.CurrentVersion.m_patch);
		}

		private static uint GetNetworkVersion()
		{
			FieldInfo fieldInfo = typeof(Version).GetField("m_networkVersion") ?? typeof(Version).GetField("c_networkVersion") ?? throw new Exception("Could not find network version field in Version class");
			return (uint)fieldInfo.GetValue(null);
		}
	}
	internal static class GUIUtils
	{
		public static bool IsHeadless { get; } = (int)SystemInfo.graphicsDeviceType == 4;
	}
	public static class HashUtils
	{
		public static string ComputeSha256Hash(string rawData)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(rawData));
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < array.Length; i++)
			{
				stringBuilder.Append(array[i].ToString("x2"));
			}
			return stringBuilder.ToString();
		}
	}
	public interface IModPrefab
	{
		GameObject Prefab { get; }

		BepInPlugin SourceMod { get; }
	}
	internal static class InputUtils
	{
		public static Key KeyCodeToKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected I4, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected I4, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected I4, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			if ((int)key <= 19)
			{
				if ((int)key <= 8)
				{
					if ((int)key == 0)
					{
						return (Key)0;
					}
					if ((int)key == 8)
					{
						return (Key)65;
					}
				}
				else
				{
					if ((int)key == 9)
					{
						return (Key)3;
					}
					if ((int)key == 13)
					{
						return (Key)2;
					}
					if ((int)key == 19)
					{
						return (Key)76;
					}
				}
			}
			else if ((int)key <= 32)
			{
				if ((int)key == 27)
				{
					return (Key)60;
				}
				if ((int)key == 32)
				{
					return (Key)1;
				}
			}
			else
			{
				switch (key - 48)
				{
				case 0:
					return (Key)50;
				case 1:
					return (Key)41;
				case 2:
					return (Key)42;
				case 3:
					return (Key)43;
				case 4:
					return (Key)44;
				case 5:
					return (Key)45;
				case 6:
					return (Key)46;
				case 7:
					return (Key)47;
				case 8:
					return (Key)48;
				case 9:
					return (Key)49;
				}
				switch (key - 97)
				{
				default:
					switch (key - 256)
					{
					case 0:
						return (Key)84;
					case 1:
						return (Key)85;
					case 2:
						return (Key)86;
					case 3:
						return (Key)87;
					case 4:
						return (Key)88;
					case 5:
						return (Key)89;
					case 6:
						return (Key)90;
					case 7:
						return (Key)91;
					case 8:
						return (Key)92;
					case 9:
						return (Key)93;
					case 10:
						return (Key)82;
					case 11:
						return (Key)78;
					case 12:
						return (Key)79;
					case 13:
						return (Key)81;
					case 14:
						return (Key)80;
					case 15:
						return (Key)77;
					case 16:
						return (Key)83;
					case 17:
						return (Key)63;
					case 18:
						return (Key)64;
					case 19:
						return (Key)62;
					case 20:
						return (Key)61;
					case 21:
						return (Key)70;
					case 22:
						return (Key)68;
					case 23:
						return (Key)69;
					case 24:
						return (Key)67;
					case 25:
						return (Key)66;
					case 26:
						return (Key)94;
					case 27:
						return (Key)95;
					case 28:
						return (Key)96;
					case 29:
						return (Key)97;
					case 30:
						return (Key)98;
					case 31:
						return (Key)99;
					case 32:
						return (Key)100;
					case 33:
						return (Key)101;
					case 34:
						return (Key)102;
					case 35:
						return (Key)103;
					case 36:
						return (Key)104;
					case 37:
						return (Key)105;
					case 45:
						return (Key)72;
					case 46:
						return (Key)75;
					case 47:
						return (Key)52;
					case 48:
						return (Key)51;
					case 49:
						return (Key)56;
					case 50:
						return (Key)55;
					case 51:
						return (Key)54;
					case 52:
						return (Key)53;
					case 54:
						return (Key)57;
					case 55:
						return (Key)57;
					case 53:
						return (Key)58;
					case 56:
						return (Key)58;
					case 57:
						return (Key)54;
					}
					break;
				case 30:
					return (Key)71;
				case 0:
					return (Key)15;
				case 1:
					return (Key)16;
				case 2:
					return (Key)17;
				case 3:
					return (Key)18;
				case 4:
					return (Key)19;
				case 5:
					return (Key)20;
				case 6:
					return (Key)21;
				case 7:
					return (Key)22;
				case 8:
					return (Key)23;
				case 9:
					return (Key)24;
				case 10:
					return (Key)25;
				case 11:
					return (Key)26;
				case 12:
					return (Key)27;
				case 13:
					return (Key)28;
				case 14:
					return (Key)29;
				case 15:
					return (Key)30;
				case 16:
					return (Key)31;
				case 17:
					return (Key)32;
				case 18:
					return (Key)33;
				case 19:
					return (Key)34;
				case 20:
					return (Key)35;
				case 21:
					return (Key)36;
				case 22:
					return (Key)37;
				case 23:
					return (Key)38;
				case 24:
					return (Key)39;
				case 25:
					return (Key)40;
				case 26:
				case 27:
				case 28:
				case 29:
					break;
				}
			}
			Logger.LogWarning($"Key {key} not found in the new input system");
			return (Key)0;
		}

		public static bool TryKeyCodeToMouseButton(KeyCode key, out MouseButton mouseButton)
		{
			//IL_0000: 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_0020: Expected I4, but got Unknown
			switch (key - 323)
			{
			case 0:
				mouseButton = (MouseButton)0;
				return true;
			case 1:
				mouseButton = (MouseButton)1;
				return true;
			case 2:
				mouseButton = (MouseButton)2;
				return true;
			case 3:
				mouseButton = (MouseButton)3;
				return true;
			case 4:
				mouseButton = (MouseButton)4;
				return true;
			default:
				mouseButton = (MouseButton)0;
				return false;
			}
		}

		public static KeyCode GetGamepadKeyCode(InputManager.GamepadButton @enum)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			return (KeyCode)(@enum switch
			{
				InputManager.GamepadButton.ButtonSouth => 330, 
				InputManager.GamepadButton.ButtonEast => 331, 
				InputManager.GamepadButton.ButtonWest => 332, 
				InputManager.GamepadButton.ButtonNorth => 333, 
				InputManager.GamepadButton.LeftShoulder => 334, 
				InputManager.GamepadButton.RightShoulder => 335, 
				InputManager.GamepadButton.SelectButton => 336, 
				InputManager.GamepadButton.StartButton => 337, 
				InputManager.GamepadButton.LeftStickButton => 338, 
				InputManager.GamepadButton.RightStickButton => 339, 
				_ => 0, 
			});
		}

		public static GamepadInput GetGamepadInput(InputManager.GamepadButton @enum)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			return (GamepadInput)(@enum switch
			{
				InputManager.GamepadButton.DPadUp => 4, 
				InputManager.GamepadButton.DPadDown => 3, 
				InputManager.GamepadButton.DPadLeft => 1, 
				InputManager.GamepadButton.DPadRight => 2, 
				InputManager.GamepadButton.ButtonSouth => 5, 
				InputManager.GamepadButton.ButtonEast => 6, 
				InputManager.GamepadButton.ButtonWest => 7, 
				InputManager.GamepadButton.ButtonNorth => 8, 
				InputManager.GamepadButton.LeftShoulder => 15, 
				InputManager.GamepadButton.RightShoulder => 16, 
				InputManager.GamepadButton.LeftTrigger => 17, 
				InputManager.GamepadButton.RightTrigger => 18, 
				InputManager.GamepadButton.SelectButton => 19, 
				InputManager.GamepadButton.StartButton => 20, 
				InputManager.GamepadButton.LeftStickButton => 11, 
				InputManager.GamepadButton.RightStickButton => 14, 
				_ => 0, 
			});
		}

		public static string GetGamepadString(InputManager.GamepadButton @enum)
		{
			return @enum switch
			{
				InputManager.GamepadButton.None => string.Empty, 
				InputManager.GamepadButton.DPadLeft => "<", 
				InputManager.GamepadButton.DPadUp => ">", 
				InputManager.GamepadButton.DPadRight => ">", 
				InputManager.GamepadButton.DPadDown => "<", 
				InputManager.GamepadButton.ButtonNorth => "Y", 
				InputManager.GamepadButton.ButtonSouth => "A", 
				InputManager.GamepadButton.ButtonWest => "X", 
				InputManager.GamepadButton.ButtonEast => "B", 
				InputManager.GamepadButton.LeftShoulder => "LB", 
				InputManager.GamepadButton.RightShoulder => "RB", 
				InputManager.GamepadButton.LeftTrigger => "LT", 
				InputManager.GamepadButton.RightTrigger => "RT", 
				InputManager.GamepadButton.StartButton => "Menu", 
				InputManager.GamepadButton.SelectButton => "Back", 
				InputManager.GamepadButton.LeftStickButton => "L", 
				InputManager.GamepadButton.RightStickButton => "R", 
				_ => string.Empty, 
			};
		}

		public static InputManager.GamepadButton GetGamepadButton(GamepadInput input)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected I4, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			switch (input - 1)
			{
			default:
				if ((int)input != 17)
				{
					if ((int)input == 18)
					{
						return InputManager.GamepadButton.RightTrigger;
					}
					return InputManager.GamepadButton.None;
				}
				return InputManager.GamepadButton.LeftTrigger;
			case 3:
				return InputManager.GamepadButton.DPadUp;
			case 2:
				return InputManager.GamepadButton.DPadDown;
			case 0:
				return InputManager.GamepadButton.DPadLeft;
			case 1:
				return InputManager.GamepadButton.DPadRight;
			}
		}

		public static InputManager.GamepadButton GetGamepadButton(string axis)
		{
			return axis switch
			{
				"JoyAxis 7" => InputManager.GamepadButton.DPadUp, 
				"-JoyAxis 7" => InputManager.GamepadButton.DPadDown, 
				"-JoyAxis 6" => InputManager.GamepadButton.DPadLeft, 
				"JoyAxis 6" => InputManager.GamepadButton.DPadRight, 
				"-JoyAxis 3" => InputManager.GamepadButton.LeftTrigger, 
				"JoyAxis 3" => InputManager.GamepadButton.RightTrigger, 
				_ => InputManager.GamepadButton.None, 
			};
		}

		public static string GetAxisPath(string axis)
		{
			return axis switch
			{
				"Mouse ScrollWheel" => "<Mouse>/scroll", 
				"JoyAxis 7" => "<Gamepad>/dpad/up", 
				"-JoyAxis 7" => "<Gamepad>/dpad/down", 
				"-JoyAxis 6" => "<Gamepad>/dpad/left", 
				"JoyAxis 6" => "<Gamepad>/dpad/right", 
				"-JoyAxis 3" => "<Gamepad>/leftTrigger", 
				"JoyAxis 3" => "<Gamepad>/rightTrigger", 
				_ => string.Empty, 
			};
		}

		public static string GetGamepadInputPath(GamepadInput input)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected I4, but got Unknown
			return (input - 1) switch
			{
				0 => "<Gamepad>/dpad/left", 
				1 => "<Gamepad>/dpad/right", 
				2 => "<Gamepad>/dpad/down", 
				3 => "<Gamepad>/dpad/up", 
				4 => "<Gamepad>/buttonSouth", 
				5 => "<Gamepad>/buttonEast", 
				6 => "<Gamepad>/buttonWest", 
				7 => "<Gamepad>/buttonNorth", 
				8 => "<Gamepad>/leftStick/x", 
				9 => "<Gamepad>/leftStick/y", 
				10 => "<Gamepad>/leftStickPress", 
				11 => "<Gamepad>/rightStick/x", 
				12 => "<Gamepad>/rightStick/y", 
				13 => "<Gamepad>/rightStickPress", 
				14 => "<Gamepad>/leftShoulder", 
				15 => "<Gamepad>/rightShoulder", 
				16 => "<Gamepad>/leftTrigger", 
				17 => "<Gamepad>/rightTrigger", 
				18 => "<Gamepad>/select", 
				19 => "<Gamepad>/start", 
				20 => "<Gamepad>/touchpadButton", 
				21 => "<Gamepad>/rightStick/up", 
				22 => "<Gamepad>/rightStick/down", 
				23 => "<Gamepad>/rightStick/left", 
				24 => "<Gamepad>/rightStick/right", 
				25 => "<Gamepad>/leftStick/up", 
				26 => "<Gamepad>/leftStick/down", 
				27 => "<Gamepad>/leftStick/left", 
				28 => "<Gamepad>/leftStick/right", 
				29 => "<Gamepad>/rightStick", 
				30 => "<Gamepad>/leftStick", 
				_ => string.Empty, 
			};
		}

		public static InputManager.GamepadButton GetGamepadButton(KeyCode key)
		{
			//IL_0000: 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_0034: Expected I4, but got Unknown
			return (key - 330) switch
			{
				0 => InputManager.GamepadButton.ButtonSouth, 
				1 => InputManager.GamepadButton.ButtonEast, 
				2 => InputManager.GamepadButton.ButtonWest, 
				3 => InputManager.GamepadButton.ButtonNorth, 
				4 => InputManager.GamepadButton.LeftShoulder, 
				5 => InputManager.GamepadButton.RightShoulder, 
				6 => InputManager.GamepadButton.SelectButton, 
				7 => InputManager.GamepadButton.StartButton, 
				8 => InputManager.GamepadButton.LeftStickButton, 
				9 => InputManager.GamepadButton.RightStickButton, 
				_ => InputManager.GamepadButton.None, 
			};
		}

		internal static void SetInputButtons(ConfigEntryBase entry)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if (ZInput.instance == null)
			{
				return;
			}
			string boundButtonName = entry.GetBoundButtonName();
			if (string.IsNullOrEmpty(boundButtonName))
			{
				return;
			}
			if (entry.SettingType == typeof(KeyCode) && ZInput.instance.m_buttons.TryGetValue(boundButtonName, out var value))
			{
				value.Rebind(ZInput.KeyCodeToPath((KeyCode)entry.BoxedValue, false));
			}
			if (entry.SettingType == typeof(KeyboardShortcut) && ZInput.instance.m_buttons.TryGetValue(boundButtonName, out value))
			{
				ButtonDef obj = value;
				KeyboardShortcut val = (KeyboardShortcut)entry.BoxedValue;
				obj.Rebind(ZInput.KeyCodeToPath(((KeyboardShortcut)(ref val)).MainKey, false));
			}
			if (entry.SettingType == typeof(InputManager.GamepadButton) && ZInput.instance.m_buttons.TryGetValue("Joy!" + boundButtonName, out value))
			{
				GamepadInput gamepadInput = GetGamepadInput((InputManager.GamepadButton)entry.BoxedValue);
				KeyCode gamepadKeyCode = GetGamepadKeyCode((InputManager.GamepadButton)entry.BoxedValue);
				if ((int)gamepadInput != 0)
				{
					value.Rebind(GetGamepadInputPath(gamepadInput));
				}
				else
				{
					value.Rebind(ZInput.KeyCodeToPath(gamepadKeyCode, false));
				}
			}
		}
	}
	public static class ModCompatibility
	{
		private static ServerVersionData LastServerVersionData = new ServerVersionData();

		private static readonly Dictionary<string, ZPackage> ClientVersions = new Dictionary<string, ZPackage>();

		internal static void Init()
		{
			Main.LogInit("ModCompatibility");
			Main.Harmony.PatchAll(typeof(ModCompatibility));
		}

		public static bool IsModuleOnServer(BaseUnityPlugin plugin)
		{
			return IsModuleOnServer(plugin.Info.Metadata.GUID);
		}

		public static bool IsModuleOnServer(string modGUID)
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance))
			{
				if (ZNet.instance.IsClientInstance())
				{
					if (LastServerVersionData.IsValid())
					{
						return LastServerVersionData.moduleGUIDs.Contains(modGUID);
					}
					return false;
				}
				if (ZNet.instance.IsServer())
				{
					return Chainloader.PluginInfos.ContainsKey(modGUID);
				}
			}
			return false;
		}

		public static bool IsJotunnOnServer()
		{
			return IsModuleOnServer("com.jotunn.jotunn");
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void ZNet_OnNewConnection(ZNet __instance, ZNetPeer peer)
		{
			LastServerVersionData.Reset();
			peer.m_rpc.Register<ZPackage>("RPC_Jotunn_ReceiveVersionData", (Action<ZRpc, ZPackage>)RPC_Jotunn_ReceiveVersionData);
		}

		[HarmonyPatch(typeof(ZNet), "RPC_ClientHandshake")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void ZNet_RPC_ClientHandshake(ZNet __instance, ZRpc rpc)
		{
			rpc.Invoke("RPC_Jotunn_ReceiveVersionData", new object[1] { new ModuleVersionData(GetEnforcableMods().ToList()).ToZPackage() });
		}

		[HarmonyPatch(typeof(ZNet), "RPC_ServerHandshake")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void ZNet_RPC_ServerHandshake(ZNet __instance, ZRpc rpc)
		{
			rpc.Invoke("RPC_Jotunn_ReceiveVersionData", new object[1] { new ModuleVersionData(GetEnforcableMods().ToList()).ToZPackage() });
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void FejdStartup_ShowConnectError(FejdStartup __instance)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			if (LastServerVersionData.IsValid() && (int)ZNet.m_connectionStatus == 3)
			{
				string text = __instance.m_connectionFailedError.text;
				((MonoBehaviour)__instance).StartCoroutine(ShowModCompatibilityErrorMessage(text));
				__instance.m_connectionFailedPanel.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(ZNet), "SendPeerInfo")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool ZNet_SendPeerInfo(ZNet __instance, ZRpc rpc, string password)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			if (ZNet.instance.IsClientInstance() && !LastServerVersionData.IsValid() && GetEnforcableMods().Any((ModModule x) => x.IsNeededOnServer()))
			{
				string text = string.Join(Environment.NewLine, from x in GetEnforcableMods()
					where x.IsNeededOnServer()
					select x.ModName);
				Logger.LogWarning("Jötunn is not installed on the server. Client has mandatory mods, cancelling connection. Mods that need to be installed on the server:" + Environment.NewLine + text);
				rpc.Invoke("Disconnect", Array.Empty<object>());
				LastServerVersionData = new ServerVersionData(new List<ModModule>());
				ZNet.m_connectionStatus = (ConnectionStatus)3;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool ZNet_RPC_PeerInfo(ZNet __instance, ZRpc rpc, ZPackage pkg)
		{
			if (!ZNet.instance.IsClientInstance())
			{
				if (!ClientVersions.ContainsKey(rpc.GetSocket().GetEndPointString()))
				{
					if (GetEnforcableMods().Any((ModModule x) => x.IsNeededOnClient()))
					{
						string text = string.Join(Environment.NewLine, from x in GetEnforcableMods()
							where x.IsNeededOnClient()
							select x.ModName);
						Logger.LogWarning("Jötunn is not installed on the client. Server has mandatory mods, cancelling connection. Mods that need to be installed on the client:" + Environment.NewLine + text);
						rpc.Invoke("Error", new object[1] { 3 });
						return false;
					}
				}
				else
				{
					ModuleVersionData serverData = new ModuleVersionData(GetEnforcableMods().ToList());
					ModuleVersionData clientData = new ModuleVersionData(ClientVersions[rpc.m_socket.GetEndPointString()]);
					if (!CompareVersionData(serverData, clientData))
					{
						Logger.LogWarning("RPC_PeerInfo: Disconnecting modded client with incompatible version message. Mods are not compatible");
						rpc.Invoke("Error", new object[1] { 3 });
						return false;
					}
				}
			}
			return true;
		}

		private static void RPC_Jotunn_ReceiveVersionData(ZRpc sender, ZPackage data)
		{
			Logger.LogDebug("Received Version package from " + sender.m_socket.GetEndPointString());
			if (!ZNet.instance.IsClientInstance())
			{
				ClientVersions[sender.m_socket.GetEndPointString()] = data;
				ModuleVersionData serverData = new ModuleVersionData(GetEnforcableMods().ToList());
				ModuleVersionData clientData = new ModuleVersionData(data);
				if (!CompareVersionData(serverData, clientData))
				{
					Logger.LogWarning("RPC_Jotunn_ReceiveVersionData: Disconnecting modded client with incompatible version message. Mods are not compatible");
					sender.Invoke("Error", new object[1] { 3 });
				}
			}
			else
			{
				LastServerVersionData = new ServerVersionData(data);
			}
		}

		internal static bool CompareVersionData(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			if (serverData == clientData)
			{
				return true;
			}
			bool result = true;
			if (!clientData.IsSupportedDataLayout)
			{
				Logger.LogWarning("Jotunn version on client is higher than server version: 2.29.1");
				result = false;
			}
			if (!serverData.IsSupportedDataLayout)
			{
				Logger.LogWarning("Jotunn version on server is higher than client version: 2.29.1");
				result = false;
			}
			foreach (ModModule item in FindNotInstalledMods(serverData, clientData))
			{
				Logger.LogWarning("Missing mod on client: " + item.ModName);
				result = false;
			}
			foreach (ModModule item2 in FindAdditionalMods(serverData, clientData))
			{
				Logger.LogWarning("Client loaded additional mod: " + item2.ModName);
				result = false;
			}
			bool legacyDataLayout = Mathf.Min(serverData.ModModuleDataLayout, clientData.ModModuleDataLayout) == 0;
			foreach (ModModule item3 in FindLowerVersionMods(serverData, clientData).Union(FindHigherVersionMods(serverData, clientData)))
			{
				ModModule modModule = clientData.FindModule(item3, legacyDataLayout);
				Logger.LogWarning($"Mod version mismatch {item3.ModName}: Server {item3.Version}, Client {modModule.Version}");
				result = false;
			}
			return result;
		}

		private static CompatibilityWindow LoadCompatWindow()
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			CustomLocalization jotunnLocalization = LocalizationManager.Instance.JotunnLocalization;
			jotunnLocalization.AddJsonFile("English", AssetUtils.LoadTextFromResources("English.json", typeof(Main).Assembly));
			jotunnLocalization.AddJsonFile("German", AssetUtils.LoadTextFromResources("German.json", typeof(Main).Assembly));
			AssetBundle val = AssetUtils.LoadAssetBundleFromResources("modcompat", typeof(Main).Assembly);
			GameObject val2 = Object.Instantiate<GameObject>(val.LoadAsset<GameObject>("CompatibilityWindow"), GUIManager.CustomGUIFront.transform);
			val.Unload(false);
			CompatibilityWindow component = val2.GetComponent<CompatibilityWindow>();
			RectTransform val3 = (RectTransform)((Component)component).transform;
			Text[] componentsInChildren = ((Component)component).GetComponentsInChildren<Text>();
			foreach (Text val4 in componentsInChildren)
			{
				GUIManager.Instance.ApplyTextStyle(val4, 18);
				val4.text = Localization.instance.Localize(val4.text);
			}
			GUIManager.Instance.ApplyWoodpanelStyle(((Component)component).transform);
			GUIManager.Instance.ApplyScrollRectStyle(component.scrollRect);
			GUIManager.Instance.ApplyButtonStyle(component.continueButton);
			GUIManager.Instance.ApplyButtonStyle(component.logFileButton);
			GUIManager.Instance.ApplyButtonStyle(component.troubleshootingButton);
			val3.anchoredPosition = new Vector2(25f, 0f);
			((Component)component).gameObject.SetWidth(1000f);
			((Component)component).gameObject.SetHeight(600f);
			return component;
		}

		private static IEnumerator ShowModCompatibilityErrorMessage(string failedConnectionText)
		{
			CompatibilityWindow compatWindow = LoadCompatWindow();
			ModuleVersionData moduleVersionData = LastServerVersionData.moduleVersionData;
			ModuleVersionData moduleVersionData2 = new ModuleVersionData(GetEnforcableMods().ToList());
			CompareVersionData(moduleVersionData, moduleVersionData2);
			compatWindow.failedConnection.text = ColoredLine(GUIManager.Instance.ValheimOrange, "$mod_compat_header_failed_connection") + failedConnectionText.Trim();
			compatWindow.localVersion.text = ColoredLine(GUIManager.Instance.ValheimOrange, "$mod_compat_header_local_version") + moduleVersionData2.ToString(showEnforce: false).Trim();
			compatWindow.remoteVersion.text = ColoredLine(GUIManager.Instance.ValheimOrange, "$mod_compat_header_remote_version") + moduleVersionData.ToString(showEnforce: false).Trim();
			compatWindow.errorMessages.text = CreateErrorMessage(moduleVersionData, moduleVersionData2).Trim();
			((Component)compatWindow).transform.localScale = Vector3.zero;
			yield return null;
			((Component)compatWindow).transform.localScale = Vector3.one;
			compatWindow.UpdateTextPositions();
			((UnityEvent)compatWindow.continueButton.onClick).AddListener((UnityAction)delegate
			{
				Object.Destroy((Object)(object)((Component)compatWindow).gameObject);
			});
			((UnityEvent)compatWindow.logFileButton.onClick).AddListener(new UnityAction(OpenLogFile));
			((UnityEvent)compatWindow.troubleshootingButton.onClick).AddListener(new UnityAction(OpenTroubleshootingPage));
			compatWindow.scrollRect.verticalNormalizedPosition = 1f;
			LastServerVersionData.Reset();
		}

		private static void OpenLogFile()
		{
			Application.OpenURL(Paths.BepInExRootPath);
		}

		private static void OpenTroubleshootingPage()
		{
			Application.OpenURL("https://github.com/Valheim-Modding/Wiki/wiki/Server-Troubleshooting");
		}

		private static string CreateErrorMessage(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			return CreateVanillaVersionErrorMessage(serverData, clientData) + CreateNotInstalledErrorMessage(serverData, clientData) + CreateLowerVersionErrorMessage(serverData, clientData) + CreateHigherVersionErrorMessage(serverData, clientData) + CreateAdditionalModsErrorMessage(serverData, clientData) + CreateFurtherStepsMessage();
		}

		private static string CreateModModuleLayoutErrorMessage(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!clientData.IsSupportedDataLayout)
			{
				return ColoredLine(Color.red, "Jotunn version on client is higher than server version: 2.29.1");
			}
			if (!serverData.IsSupportedDataLayout)
			{
				return ColoredLine(Color.red, "Jotunn version on server is higher than client version: 2.29.1");
			}
			if (serverData.ModModuleDataLayout != clientData.ModModuleDataLayout)
			{
				return ColoredLine(Color.red, "Jotunn versions on server and client are not compatible.");
			}
			return string.Empty;
		}

		private static string CreateVanillaVersionErrorMessage(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			if (serverData.NetworkVersion == 0 || clientData.NetworkVersion == 0)
			{
				return string.Empty;
			}
			if (serverData.NetworkVersion > clientData.NetworkVersion)
			{
				return ColoredLine(Color.red, "$mod_compat_header_valheim_version") + ColoredLine(GUIManager.Instance.ValheimOrange, "$mod_compat_valheim_version_error_description", $"{serverData.NetworkVersion}", $"{clientData.NetworkVersion}") + ColoredLine(Color.white, "$mod_compat_valheim_version_upgrade") + Environment.NewLine;
			}
			if (serverData.NetworkVersion < clientData.NetworkVersion)
			{
				return ColoredLine(Color.red, "$mod_compat_header_valheim_version") + ColoredLine(GUIManager.Instance.ValheimOrange, "$mod_compat_valheim_version_error_description", $"{serverData.NetworkVersion}", $"{clientData.NetworkVersion}") + ColoredLine(Color.white, "$mod_compat_valheim_version_downgrade") + Environment.NewLine;
			}
			return string.Empty;
		}

		private static string CreateNotInstalledErrorMessage(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			List<ModModule> list = FindNotInstalledMods(serverData, clientData);
			if (list.Count == 0)
			{
				return string.Empty;
			}
			return ColoredLine(Color.red, "$mod_compat_header_missing_mods") + ColoredLine(GUIManager.Instance.ValheimOrange, "$mod_compat_missing_mods_description") + string.Join("", list.Select((ModModule serverModule) => ColoredLine(Color.white, "$mod_compat_missing_mod", serverModule.ModName ?? "", $"{serverModule.Version}"))) + Environment.NewLine;
		}

		private static string CreateLowerVersionErrorMessage(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			List<ModModule> list = FindLowerVersionMods(serverData, clientData);
			if (list.Count == 0)
			{
				return string.Empty;
			}
			return ColoredLine(Color.red, "$mod_compat_header_update_needed") + string.Join("", list.Select((ModModule serverModule) => ColoredLine(Color.white, "$mod_compat_mod_update", serverModule.ModName, serverModule.GetVersionString()))) + Environment.NewLine;
		}

		private static string CreateHigherVersionErrorMessage(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			List<ModModule> list = FindHigherVersionMods(serverData, clientData);
			if (list.Count == 0)
			{
				return string.Empty;
			}
			return ColoredLine(Color.red, "$mod_compat_header_downgrade_needed") + string.Join("", list.Select((ModModule serverModule) => ColoredLine(Color.white, "$mod_compat_mod_downgrade", serverModule.ModName, serverModule.GetVersionString()))) + Environment.NewLine;
		}

		private static string CreateAdditionalModsErrorMessage(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			List<ModModule> list = FindAdditionalMods(serverData, clientData);
			if (list.Count == 0)
			{
				return string.Empty;
			}
			return ColoredLine(Color.red, "$mod_compat_header_additional_mods") + ColoredLine(GUIManager.Instance.ValheimOrange, "$mod_compat_additional_mods_description") + string.Join("", list.Select((ModModule clientModule) => ColoredLine(Color.white, "$mod_compat_additional_mod", clientModule.ModName, $"{clientModule.Version}"))) + Environment.NewLine;
		}

		private static string CreateFurtherStepsMessage()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			return ColoredLine(GUIManager.Instance.ValheimOrange, "$mod_compat_header_further_steps") + ColoredLine(Color.white, "$mod_compat_further_steps_description") + Environment.NewLine;
		}

		private static List<ModModule> FindNotInstalledMods(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			return FindMods(serverData, clientData, (ModModule serverModule, ModModule clientModule) => serverModule.IsNeededOnClient() && clientModule == null).ToList();
		}

		private static List<ModModule> FindAdditionalMods(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			return FindMods(clientData, serverData, (ModModule clientModule, ModModule serverModule) => clientModule.IsNeededOnServer() && serverModule == null).ToList();
		}

		private static List<ModModule> FindLowerVersionMods(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			return FindMods(serverData, clientData, (ModModule serverModule, ModModule clientModule) => clientModule != null && ModModule.IsLowerVersion(serverModule, clientModule, serverModule.VersionStrictness)).ToList();
		}

		private static List<ModModule> FindHigherVersionMods(ModuleVersionData serverData, ModuleVersionData clientData)
		{
			return FindMods(serverData, clientData, (ModModule serverModule, ModModule clientModule) => clientModule != null && ModModule.IsLowerVersion(clientModule, serverModule, serverModule.VersionStrictness)).ToList();
		}

		private static IEnumerable<ModModule> FindMods(ModuleVersionData baseModules, ModuleVersionData additionalModules, Func<ModModule, ModModule, bool> predicate)
		{
			bool legacyDataLayout = Mathf.Min(baseModules.ModModuleDataLayout, additionalModules.ModModuleDataLayout) == 0;
			foreach (ModModule module in baseModules.Modules)
			{
				ModModule arg = additionalModules.FindModule(module, legacyDataLayout);
				if (predicate(module, arg))
				{
					yield return module;
				}
			}
		}

		internal static IEnumerable<ModModule> GetEnforcableMods()
		{
			foreach (KeyValuePair<string, BaseUnityPlugin> item in from x in BepInExUtils.GetDependentPlugins(includeJotunn: true)
				orderby x.Key
				select x)
			{
				NetworkCompatibilityAttribute networkCompatibilityAttribute = item.Value.GetNetworkCompatibilityAttribute();
				if (networkCompatibilityAttribute != null)
				{
					yield return new ModModule(item.Value.Info.Metadata, networkCompatibilityAttribute);
				}
				else
				{
					yield return new ModModule(item.Value.Info.Metadata);
				}
			}
		}

		private static string ColoredLine(Color color, string inner, params string[] words)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return "<color=#" + ColorUtility.ToHtmlStringRGB(color) + ">" + Localization.instance.Localize(inner, words) + "</color>" + Environment.NewLine;
		}
	}
	internal class ModModule
	{
		public const int LegacyDataLayoutVersion = 0;

		public const int CurrentDataLayoutVersion = 1;

		public static readonly HashSet<int> SupportedDataLayouts = new HashSet<int> { 0, 1 };

		private string guid;

		public int DataLayoutVersion { get; private set; }

		public string ModID
		{
			get
			{
				if (DataLayoutVersion != 0)
				{
					return guid;
				}
				return ModName;
			}
		}

		public string ModName { get; }

		public Version Version { get; }

		public CompatibilityLevel CompatibilityLevel { get; }

		public VersionStrictness VersionStrictness { get; }

		public bool IsLegacyDataLayout => false;

		public ModModule(string guid, string name, Version version, CompatibilityLevel compatibilityLevel, VersionStrictness versionStrictness)
		{
			DataLayoutVersion = 1;
			this.guid = guid;
			ModName = name;
			Version = version;
			CompatibilityLevel = compatibilityLevel;
			VersionStrictness = versionStrictness;
		}

		public ModModule(ZPackage pkg, bool legacy)
		{
			if (legacy)
			{
				DataLayoutVersion = 0;
				ModName = pkg.ReadString();
				int major = pkg.ReadInt();
				int minor = pkg.ReadInt();
				int num = pkg.ReadInt();
				Version = ((num >= 0) ? new Version(major, minor, num) : new Version(major, minor));
				CompatibilityLevel = (CompatibilityLevel)pkg.ReadInt();
				VersionStrictness = (VersionStrictness)pkg.ReadInt();
				return;
			}
			DataLayoutVersion = pkg.ReadInt();
			if (!IsSupportedDataLayout())
			{
				throw new NotSupportedException($"{DataLayoutVersion} is not a supported data layout version.");
			}
			if (DataLayoutVersion == 1)
			{
				guid = pkg.ReadString();
				ModName = pkg.ReadString();
				int major2 = pkg.ReadInt();
				int minor2 = pkg.ReadInt();
				int num2 = pkg.ReadInt();
				Version = ((num2 >= 0) ? new Version(major2, minor2, num2) : new Version(major2, minor2));
				CompatibilityLevel = (CompatibilityLevel)pkg.ReadInt();
				VersionStrictness = (VersionStrictness)pkg.ReadInt();
			}
		}

		public void WriteToPackage(ZPackage pkg, bool legacy)
		{
			if (legacy)
			{
				pkg.Write(ModName);
				pkg.Write(Version.Major);
				pkg.Write(Version.Minor);
				pkg.Write(Version.Build);
				pkg.Write((int)CompatibilityLevel);
				pkg.Write((int)VersionStrictness);
			}
			else
			{
				pkg.Write(DataLayoutVersion);
				pkg.Write(guid);
				pkg.Write(ModName);
				pkg.Write(Version.Major);
				pkg.Write(Version.Minor);
				pkg.Write(Version.Build);
				pkg.Write((int)CompatibilityLevel);
				pkg.Write((int)VersionStrictness);
			}
		}

		public ModModule(BepInPlugin plugin, NetworkCompatibilityAttribute networkAttribute)
		{
			DataLayoutVersion = 1;
			guid = plugin.GUID;
			ModName = plugin.Name;
			Version = plugin.Version;
			CompatibilityLevel = networkAttribute.EnforceModOnClients;
			VersionStrictness = networkAttribute.EnforceSameVersion;
		}

		public ModModule(BepInPlugin plugin)
		{
			DataLayoutVersion = 1;
			guid = plugin.GUID;
			ModName = plugin.Name;
			Version = plugin.Version;
			CompatibilityLevel = CompatibilityLevel.NotEnforced;
			VersionStrictness = VersionStrictness.None;
		}

		public string GetVersionString()
		{
			if (Version.Build >= 0)
			{
				return $"{Version.Major}.{Version.Minor}.{Version.Build}";
			}
			return $"{Version.Major}.{Version.Minor}";
		}

		public bool IsNeededOnServer()
		{
			if (CompatibilityLevel != CompatibilityLevel.EveryoneMustHaveMod)
			{
				return CompatibilityLevel == CompatibilityLevel.ServerMustHaveMod;
			}
			return true;
		}

		public bool IsNeededOnClient()
		{
			if (CompatibilityLevel != CompatibilityLevel.EveryoneMustHaveMod)
			{
				return CompatibilityLevel == CompatibilityLevel.ClientMustHaveMod;
			}
			return true;
		}

		public bool IsNotEnforced()
		{
			if (CompatibilityLevel != CompatibilityLevel.NotEnforced)
			{
				return CompatibilityLevel == CompatibilityLevel.NoNeedForSync;
			}
			return true;
		}

		public bool OnlyVersionCheck()
		{
			if (CompatibilityLevel != CompatibilityLevel.OnlySyncWhenInstalled)
			{
				return CompatibilityLevel == CompatibilityLevel.VersionCheckOnly;
			}
			return true;
		}

		public bool IsSupportedDataLayout()
		{
			return SupportedDataLayouts.Contains(DataLayoutVersion);
		}

		public static bool IsLowerVersion(ModModule baseModule, ModModule compareModule, VersionStrictness strictness)
		{
			if (strictness == VersionStrictness.None)
			{
				return false;
			}
			bool flag = compareModule.Version.Major < baseModule.Version.Major;
			bool flag2 = compareModule.Version.Minor < baseModule.Version.Minor;
			bool flag3 = compareModule.Version.Build < baseModule.Version.Build;
			bool flag4 = compareModule.Version.Major == baseModule.Version.Major;
			bool flag5 = compareModule.Version.Minor == baseModule.Version.Minor;
			if (strictness >= VersionStrictness.Major && flag)
			{
				return true;
			}
			if (strictness >= VersionStrictness.Minor && flag2 && (flag || flag4))
			{
				return true;
			}
			if (strictness >= VersionStrictness.Patch && flag3 && (flag2 || flag5) && (flag || flag4))
			{
				return true;
			}
			return false;
		}
	}
	internal class ModuleVersionData
	{
		public Version ValheimVersion { get; internal set; }

		public List<ModModule> Modules { get; internal set; } = new List<ModModule>();

		public string VersionString { get; internal set; } = string.Empty;

		public uint NetworkVersion { get; internal set; }

		public int ModModuleDataLayout { get; private set; }

		public bool IsSupportedDataLayout => ModModule.SupportedDataLayouts.Contains(ModModuleDataLayout);

		internal ModuleVersionData(List<ModModule> versionData)
		{
			ValheimVersion = GameVersions.ValheimVersion;
			VersionString = GetVersionString();
			NetworkVersion = GameVersions.NetworkVersion;
			Modules = new List<ModModule>(versionData);
			ModModuleDataLayout = GetModModuleDataLayoutVersion(Modules);
		}

		internal ModuleVersionData(Version valheimVersion, List<ModModule> versionData)
		{
			ValheimVersion = valheimVersion;
			VersionString = GetVersionString();
			NetworkVersion = GameVersions.NetworkVersion;
			Modules = new List<ModModule>(versionData);
			ModModuleDataLayout = GetModModuleDataLayoutVersion(Modules);
		}

		internal ModuleVersionData(ZPackage pkg)
		{
			try
			{
				pkg.SetPos(0);
				ValheimVersion = new Version(pkg.ReadInt(), pkg.ReadInt(), pkg.ReadInt());
				for (int num = pkg.ReadInt(); num > 0; num--)
				{
					Modules.Add(new ModModule(pkg, legacy: true));
				}
				if (pkg.m_reader.BaseStream.Position != pkg.m_reader.BaseStream.Length)
				{
					VersionString = pkg.ReadString();
				}
				if (pkg.m_reader.BaseStream.Position != pkg.m_reader.BaseStream.Length)
				{
					NetworkVersion = pkg.ReadUInt();
				}
				if (pkg.m_reader.BaseStream.Position == pkg.m_reader.BaseStream.Length)
				{
					return;
				}
				List<ModModule> list = new List<ModModule>();
				int num2 = pkg.ReadInt();
				int pos = pkg.GetPos();
				while (num2 > 0)
				{
					try
					{
						ModModule item = new ModModule(pkg, legacy: false);
						list.Add(item);
						num2--;
					}
					catch (NotSupportedException ex)
					{
						pkg.SetPos(pos);
						ModModuleDataLayout = pkg.ReadInt();
						Logger.LogError($"Could not parse unsupported data layout version {ModModuleDataLayout} from zPackage");
						Logger.LogError(ex.Message);
						break;
					}
				}
				Modules = list;
				ModModuleDataLayout = GetModModuleDataLayoutVersion(Modules);
			}
			catch (Exception ex2)
			{
				Logger.LogError("Could not deserialize version message data from zPackage");
				Logger.LogError(ex2.Message);
			}
		}

		public ZPackage ToZPackage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(ValheimVersion.Major);
			val.Write(ValheimVersion.Minor);
			val.Write(ValheimVersion.Build);
			val.Write(Modules.Count);
			foreach (ModModule module in Modules)
			{
				module.WriteToPackage(val, legacy: true);
			}
			val.Write(VersionString);
			val.Write(NetworkVersion);
			val.Write(Modules.Count);
			foreach (ModModule module2 in Modules)
			{
				module2.WriteToPackage(val, legacy: false);
			}
			return val;
		}

		public override int GetHashCode()
		{
			return (((ValheimVersion != null) ? ValheimVersion.GetHashCode() : 0) * 397) ^ ((Modules != null) ? Modules.GetHashCode() : 0);
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (string.IsNullOrEmpty(VersionString))
			{
				stringBuilder.AppendLine($"Valheim {ValheimVersion.Major}.{ValheimVersion.Minor}.{ValheimVersion.Build}");
			}
			else
			{
				stringBuilder.AppendLine("Valheim " + VersionString);
			}
			foreach (ModModule module in Modules)
			{
				stringBuilder.AppendLine($"{module.ModName} {module.GetVersionString()} {module.CompatibilityLevel} {module.VersionStrictness}");
			}
			return stringBuilder.ToString();
		}

		public string ToString(bool showEnforce)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string text = VersionString;
			if (string.IsNullOrEmpty(text))
			{
				text = $"Valheim {ValheimVersion.Major}.{ValheimVersion.Minor}.{ValheimVersion.Build}";
			}
			if (NetworkVersion != 0)
			{
				stringBuilder.AppendLine($"Valheim {text} (n-{NetworkVersion})");
			}
			else
			{
				stringBuilder.AppendLine("Valheim " + text);
			}
			foreach (ModModule module in Modules)
			{
				stringBuilder.AppendLine(module.ModName + " " + module.GetVersionString() + (showEnforce ? $" {module.CompatibilityLevel} {module.VersionStrictness}" : ""));
			}
			return stringBuilder.ToString();
		}

		public ModModule FindModule(ModModule modModule, bool legacyDataLayout)
		{
			if (legacyDataLayout)
			{
				return Modules.FirstOrDefault((ModModule x) => x.ModName == modModule.ModName);
			}
			return Modules.FirstOrDefault((ModModule x) => x.ModID == modModule.ModID);
		}

		public bool HasModule(ModModule modModule, bool legacyDataLayout)
		{
			return FindModule(modModule, legacyDataLayout) != null;
		}

		private static string GetVersionString()
		{
			return Version.GetVersionString(false).Replace("-ServerCharacters", "");
		}

		private static int GetModModuleDataLayoutVersion(List<ModModule> modules)
		{
			if (modules.Any((ModModule x) => x.DataLayoutVersion != modules.FirstOrDefault()?.DataLayoutVersion))
			{
				throw new NotSupportedException("DataVersionLayout is not the same for all ModModule instances.");
			}
			return modules.FirstOrDefault()?.DataLayoutVersion ?? 1;
		}
	}
	public enum CompatibilityLevel
	{
		[Obsolete("Use NotEnforced instead")]
		NoNeedForSync,
		[Obsolete("Use VersionCheckOnly")]
		OnlySyncWhenInstalled,
		EveryoneMustHaveMod,
		ClientMustHaveMod,
		ServerMustHaveMod,
		VersionCheckOnly,
		NotEnforced
	}
	public enum VersionStrictness
	{
		None,
		Major,
		Minor,
		Patch
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class)]
	public class NetworkCompatibilityAttribute : Attribute
	{
		public CompatibilityLevel EnforceModOnClients { get; set; }

		public VersionStrictness EnforceSameVersion { get; set; }

		public NetworkCompatibilityAttribute(CompatibilityLevel enforceMod, VersionStrictness enforceVersion)
		{
			EnforceModOnClients = enforceMod;
			EnforceSameVersion = enforceVersion;
		}
	}
	internal class ServerVersionData
	{
		public ModuleVersionData moduleVersionData { get; set; }

		public HashSet<string> moduleGUIDs { get; set; }

		internal ServerVersionData()
		{
		}

		internal ServerVersionData(List<ModModule> versionData)
		{
			moduleVersionData = new ModuleVersionData(versionData);
			moduleGUIDs = new HashSet<string>((from x in moduleVersionData.Modules
				where x.ModID != null
				select x.ModID).ToList());
		}

		internal ServerVersionData(Version valheimVersion, List<ModModule> versionData)
		{
			moduleVersionData = new ModuleVersionData(valheimVersion, versionData);
			moduleGUIDs = new HashSet<string>((from x in moduleVersionData.Modules
				where x.ModID != null
				select x.ModID).ToList());
		}

		internal ServerVersionData(ZPackage pkg)
		{
			moduleVersionData = new ModuleVersionData(pkg);
			moduleGUIDs = new HashSet<string>((from x in moduleVersionData.Modules
				where x.ModID != null
				select x.ModID).ToList());
		}

		internal bool IsValid()
		{
			if (moduleVersionData != null)
			{
				return moduleGUIDs != null;
			}
			return false;
		}

		internal void Reset()
		{
			moduleVersionData = null;
			moduleGUIDs = null;
		}
	}
	public enum AdminOnlyStrictness
	{
		Always,
		IfOnServer
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class)]
	public class SynchronizationModeAttribute : Attribute
	{
		public AdminOnlyStrictness EnforceAdminOnly { get; set; }

		public SynchronizationModeAttribute(AdminOnlyStrictness enforceAdminOnly)
		{
			EnforceAdminOnly = enforceAdminOnly;
		}

		public bool ShouldAlwaysEnforceAdminOnly()
		{
			return EnforceAdminOnly == AdminOnlyStrictness.Always;
		}
	}
	public class ModQuery
	{
		private class ModPrefab : IModPrefab
		{
			public GameObject Prefab { get; }

			public BepInPlugin SourceMod { get; }

			public ModPrefab(GameObject prefab, BepInPlugin mod)
			{
				Prefab = prefab;
				SourceMod = mod;
			}
		}

		private class ZNetSceneState
		{
			public bool valid;

			public readonly Dictionary<int, GameObject> namedPrefabs;

			public readonly List<GameObject> prefabs;

			public ZNetSceneState(ZNetScene zNetScene)
			{
				valid = Object.op_Implicit((Object)(object)zNetScene);
				if (valid)
				{
					namedPrefabs = new Dictionary<int, GameObject>(zNetScene.m_namedPrefabs);
					prefabs = new List<GameObject>(zNetScene.m_prefabs);
				}
			}

			public void AddNewPrefabs(ZNetScene zNetScene, PluginInfo plugin)
			{
				if (valid && Object.op_Implicit((Object)(object)zNetScene))
				{
					AddPrefabs(namedPrefabs, zNetScene.m_namedPrefabs, plugin.Metadata);
					AddPrefabs(prefabs, zNetScene.m_prefabs, plugin.Metadata);
				}
			}
		}

		private class ObjectDBState
		{
			public bool valid;

			public List<GameObject> items;

			public List<Recipe> recipes;

			public Dictionary<int, GameObject> itemByHash;

			public ObjectDBState(ObjectDB objectDB)
			{
				valid = Object.op_Implicit((Object)(object)objectDB);
				if (valid)
				{
					items = new List<GameObject>(objectDB.m_items);
					recipes = new List<Recipe>(objectDB.m_recipes);
					itemByHash = new Dictionary<int, GameObject>(objectDB.m_itemByHash);
				}
			}

			public void AddNewPrefabs(ObjectDB objectDB, PluginInfo plugin)
			{
				if (valid && Object.op_Implicit((Object)(object)objectDB))
				{
					AddPrefabs(items, objectDB.m_items, plugin.Metadata);
					AddPrefabs(itemByHash, objectDB.m_itemByHash, plugin.Metadata);
					AddRecipes(recipes, objectDB.m_recipes, plugin.Metadata);
				}
			}
		}

		private static readonly Dictionary<string, Dictionary<int, ModPrefab>> Prefabs = new Dictionary<string, Dictionary<int, ModPrefab>>();

		private static readonly Dictionary<string, List<Recipe>> Recipes = new Dictionary<string, List<Recipe>>();

		private static Tuple<ZNetSceneState, ObjectDBState> state;

		private static readonly HashSet<MethodInfo> PatchedMethods = new HashSet<MethodInfo>();

		private static readonly HarmonyMethod PrePatch = new HarmonyMethod(AccessTools.Method(typeof(ModQuery), "BeforePatch", (Type[])null, (Type[])null));

		private static readonly HarmonyMethod PostPatch = new HarmonyMethod(AccessTools.Method(typeof(ModQuery), "AfterPatch", (Type[])null, (Type[])null));

		private static bool enabled = false;

		internal static void Init()
		{
			Main.LogInit("ModQuery");
			Main.Harmony.PatchAll(typeof(ModQuery));
		}

		public static void Enable()
		{
			if (!enabled)
			{
				Init();
			}
			enabled = true;
		}

		public static IEnumerable<IModPrefab> GetPrefabs()
		{
			List<IModPrefab> list = new List<IModPrefab>();
			foreach (KeyValuePair<string, Dictionary<int, ModPrefab>> prefab in Prefabs)
			{
				list.AddRange(prefab.Value.Values);
			}
			list.AddRange(PrefabManager.Instance.Prefabs.Values);
			return list;
		}

		public static IEnumerable<IModPrefab> GetPrefabs(string modGuid)
		{
			List<IModPrefab> list = new List<IModPrefab>();
			list.AddRange(Prefabs[modGuid].Values);
			list.AddRange(PrefabManager.Instance.Prefabs.Values.Where((CustomPrefab x) => x.SourceMod.GUID.Equals(modGuid)));
			return list;
		}

		public static IModPrefab GetPrefab(string name)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (PrefabManager.Instance.Prefabs.TryGetValue(name, out var value))
			{
				return value;
			}
			foreach (KeyValuePair<string, Dictionary<int, ModPrefab>> prefab in Prefabs)
			{
				if (prefab.Value.ContainsKey(stableHashCode))
				{
					return prefab.Value[stableHashCode];
				}
			}
			return null;
		}

		[HarmonyPatch(typeof(ZNetScene), "OnDestroy")]
		[HarmonyPostfix]
		private static void ZNetSceneOnDestroy()
		{
			Prefabs.Clear();
			Recipes.Clear();
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[HarmonyPostfix]
		private static void FejdStartup_Awake_Postfix()
		{
			FindAndPatchPatches(AccessTools.Method(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null));
			FindAndPatchPatches(AccessTools.Method(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null));
			FindAndPatchPatches(AccessTools.Method(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null));
			FindAndPatchPatches(AccessTools.Method(typeof(ObjectDB), "UpdateRegisters", (Type[])null, (Type[])null));
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		[HarmonyPrefix]
		[HarmonyPriority(1000)]
		private static void ObjectDBAwake(ObjectDB __instance)
		{
			__instance.UpdateRegisters();
		}

		private static void FindAndPatchPatches(MethodBase methodInfo)
		{
			PatchPatches(Harmony.GetPatchInfo(methodInfo)?.Prefixes);
			PatchPatches(Harmony.GetPatchInfo(methodInfo)?.Postfixes);
			PatchPatches(Harmony.GetPatchInfo(methodInfo)?.Finalizers);
		}

		private static void PatchPatches(ICollection<Patch> patches)
		{
			if (patches == null)
			{
				return;
			}
			foreach (Patch patch in patches)
			{
				if (!(patch.owner == "com.jotunn.jotunn") && !PatchedMethods.Contains(patch.PatchMethod))
				{
					PatchedMethods.Add(patch.PatchMethod);
					try
					{
						Main.Harmony.Patch((MethodBase)patch.PatchMethod, PrePatch, PostPatch, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
					catch (Exception)
					{
						Logger.LogWarning($"Failed to patch {patch.PatchMethod} from {patch.owner}");
					}
				}
			}
		}

		private static void BeforePatch(object[] __args)
		{
			ObjectDB objectDB = GetObjectDB(__args);
			ZNetScene zNetScene = GetZNetScene(__args);
			state = new Tuple<ZNetSceneState, ObjectDBState>(new ZNetSceneState(zNetScene), new ObjectDBState(objectDB));
		}

		private static void AfterPatch(object[] __args)
		{
			if (state != null && (state.Item1.valid || state.Item2.valid))
			{
				PluginInfo pluginInfoFromAssembly = BepInExUtils.GetPluginInfoFromAssembly(ReflectionHelper.GetCallingAssembly());
				if (pluginInfoFromAssembly != null)
				{
					state.Item1.AddNewPrefabs(GetZNetScene(__args), pluginInfoFromAssembly);
					state.Item2.AddNewPrefabs(GetObjectDB(__args), pluginInfoFromAssembly);
				}
			}
		}

		private static void AddPrefabs(IEnumerable<GameObject> before, IEnumerable<GameObject> after, BepInPlugin plugin)
		{
			AddPrefabs(new HashSet<GameObject>(before), new HashSet<GameObject>(after), plugin);
		}

		private static void AddPrefabs(Dictionary<int, GameObject> before, Dictionary<int, GameObject> after, BepInPlugin plugin)
		{
			AddPrefabs(new HashSet<GameObject>(before.Values), new HashSet<GameObject>(after.Values), plugin);
		}

		private static void AddPrefabs(HashSet<GameObject> before, HashSet<GameObject> after, BepInPlugin plugin)
		{
			if (!Prefabs.ContainsKey(plugin.GUID))
			{
				Prefabs.Add(plugin.GUID, new Dictionary<int, ModPrefab>());
			}
			foreach (GameObject item in after)
			{
				if (Object.op_Implicit((Object)(object)item) && !before.Contains(item))
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)item).name);
					if (!Prefabs[plugin.GUID].ContainsKey(stableHashCode))
					{
						Prefabs[plugin.GUID].Add(stableHashCode, new ModPrefab(item, plugin));
					}
				}
			}
		}

		private static void AddRecipes(IEnumerable<Recipe> before, IEnumerable<Recipe> after, BepInPlugin plugin)
		{
			AddRecipes(new HashSet<Recipe>(before), new HashSet<Recipe>(after), plugin);
		}

		private static void AddRecipes(HashSet<Recipe> before, HashSet<Recipe> after, BepInPlugin plugin)
		{
			if (!Recipes.ContainsKey(plugin.GUID))
			{
				Recipes.Add(plugin.GUID, new List<Recipe>());
			}
			foreach (Recipe item in after)
			{
				if (!before.Contains(item) && !Recipes[plugin.GUID].Contains(item))
				{
					Recipes[plugin.GUID].Add(item);
				}
			}
		}

		private static ZNetScene GetZNetScene(object[] __args)
		{
			foreach (object obj in __args)
			{
				ZNetScene val = (ZNetScene)((obj is ZNetScene) ? obj : null);
				if (val != null)
				{
					return val;
				}
			}
			return ZNetScene.instance;
		}

		private static ObjectDB GetObjectDB(object[] __args)
		{
			foreach (object obj in __args)
			{
				ObjectDB val = (ObjectDB)((obj is ObjectDB) ? obj : null);
				if (val != null)
				{
					return val;
				}
			}
			return ObjectDB.instance;
		}
	}
	public static class ModRegistry
	{
		public class ModInfo
		{
			public string GUID { get; internal set; }

			public string Name { get; internal set; }

			public Version Version { get; internal set; }

			public IEnumerable<CustomPrefab> Prefabs => GetPrefabs(GUID);

			public IEnumerable<CustomItem> Items => GetItems(GUID);

			public IEnumerable<CustomRecipe> Recipes => GetRecipes(GUID);

			public IEnumerable<CustomItemConversion> ItemConversions => GetItemConversions(GUID);

			public IEnumerable<CustomStatusEffect> StatusEffects => GetStatusEffects(GUID);

			public IEnumerable<CustomPieceTable> PieceTables => GetPieceTables(GUID);

			public IEnumerable<CustomPiece> Pieces => GetPieces(GUID);

			public IEnumerable<CustomLocation> Locations => GetLocations(GUID);

			public IEnumerable<CustomVegetation> Vegetation => GetVegetation(GUID);

			public IEnumerable<CustomClutter> Clutter => GetClutter(GUID);

			public IEnumerable<CustomCreature> Creatures => GetCreatures(GUID);

			public IEnumerable<ConsoleCommand> Commands => GetCommands(GUID);

			public IEnumerable<CustomLocalization> Translations => GetTranslations(GUID);
		}

		public static IEnumerable<ModInfo> GetMods(bool includingJotunn = false)
		{
			return BepInExUtils.GetDependentPlugins(includingJotunn).Values.Select((BaseUnityPlugin mod) => new ModInfo
			{
				GUID = mod.Info.Metadata.GUID,
				Name = mod.Info.Metadata.Name,
				Version = mod.Info.Metadata.Version
			});
		}

		public static IEnumerable<CustomPrefab> GetPrefabs()
		{
			return PrefabManager.Instance.Prefabs.Values;
		}

		public static IEnumerable<CustomPrefab> GetPrefabs(string modGuid)
		{
			return GetPrefabs().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomItem> GetItems()
		{
			return ItemManager.Instance.Items.Values;
		}

		public static IEnumerable<CustomItem> GetItems(string modGuid)
		{
			return GetItems().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomRecipe> GetRecipes()
		{
			return ItemManager.Instance.Recipes;
		}

		public static IEnumerable<CustomRecipe> GetRecipes(string modGuid)
		{
			return GetRecipes().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomItemConversion> GetItemConversions()
		{
			return ItemManager.Instance.ItemConversions;
		}

		public static IEnumerable<CustomItemConversion> GetItemConversions(string modGuid)
		{
			return GetItemConversions().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomStatusEffect> GetStatusEffects()
		{
			return ItemManager.Instance.StatusEffects;
		}

		public static IEnumerable<CustomStatusEffect> GetStatusEffects(string modGuid)
		{
			return GetStatusEffects().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomPieceTable> GetPieceTables()
		{
			return PieceManager.Instance.PieceTables.AsReadOnly();
		}

		public static IEnumerable<CustomPieceTable> GetPieceTables(string modGuid)
		{
			return GetPieceTables().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomPiece> GetPieces()
		{
			return PieceManager.Instance.Pieces.Values;
		}

		public static IEnumerable<CustomPiece> GetPieces(string modGuid)
		{
			return GetPieces().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomLocation> GetLocations()
		{
			return ZoneManager.Instance.Locations.Values;
		}

		public static IEnumerable<CustomLocation> GetLocations(string modGuid)
		{
			return GetLocations().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomVegetation> GetVegetation()
		{
			return ZoneManager.Instance.Vegetations.Values;
		}

		public static IEnumerable<CustomVegetation> GetVegetation(string modGuid)
		{
			return ZoneManager.Instance.Vegetations.Values.Where((CustomVegetation x) => x.SourceMod.GUID.Equals(modGuid));
		}

		public static IEnumerable<CustomClutter> GetClutter()
		{
			return ZoneManager.Instance.Clutter.Values;
		}

		public static IEnumerable<CustomClutter> GetClutter(string modGuid)
		{
			return GetClutter().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomCreature> GetCreatures()
		{
			return CreatureManager.Instance.Creatures.AsReadOnly();
		}

		public static IEnumerable<CustomCreature> GetCreatures(string modGuid)
		{
			return GetCreatures().FilterByMod(modGuid);
		}

		public static IEnumerable<ConsoleCommand> GetCommands()
		{
			return CommandManager.Instance.CustomCommands;
		}

		public static IEnumerable<ConsoleCommand> GetCommands(string modGuid)
		{
			return GetCommands().FilterByMod(modGuid);
		}

		public static IEnumerable<CustomLocalization> GetTranslations()
		{
			return LocalizationManager.Instance.Localizations.Values;
		}

		public static IEnumerable<CustomLocalization> GetTranslations(string modGuid)
		{
			return GetTranslations().FilterByMod(modGuid);
		}

		private static IEnumerable<T> FilterByMod<T>(this IEnumerable<T> list, string modGuid) where T : CustomEntity
		{
			return list.Where((T x) => x.SourceMod.GUID == modGuid);
		}
	}
	internal class PatchInit
	{
		[Obsolete]
		internal static void InitializePatches()
		{
			List<Tuple<MethodInfo, int>> list = new List<Tuple<MethodInfo, int>>();
			HashSet<Assembly> hashSet = new HashSet<Assembly>();
			foreach (BaseUnityPlugin value in BepInExUtils.GetDependentPlugins().Values)
			{
				try
				{
					Assembly assembly = ((object)value).GetType().Assembly;
					if (hashSet.Contains(assembly))
					{
						continue;
					}
					hashSet.Add(assembly);
					Type[] types = assembly.GetTypes();
					foreach (Type type in types)
					{
						try
						{
							foreach (MethodInfo item in from x in type.GetMethods(BindingFlags.Static | BindingFlags.Public)
								where x.GetCustomAttributes(typeof(PatchInitAttribute), inherit: false).Length == 1
								select x)
							{
								PatchInitAttribute patchInitAttribute = item.GetCustomAttributes(typeof(PatchInitAttribute), inherit: false).FirstOrDefault() as PatchInitAttribute;
								list.Add(new Tuple<MethodInfo, int>(item, patchInitAttribute.Priority));
							}
						}
						catch (Exception)
						{
						}
					}
				}
				catch (Exception)
				{
				}
			}
			foreach (Tuple<MethodInfo, int> item2 in list.OrderBy((Tuple<MethodInfo, int> x) => x.Item2))
			{
				Logger.LogDebug("Applying patches in " + item2.Item1.DeclaringType.Name + "." + item2.Item1.Name);
				item2.Item1.Invoke(null, null);
			}
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	[Obsolete("Use Harmony patches or your Start method instead")]
	public class PatchInitAttribute : Attribute
	{
		public int Priority { get; set; }

		public PatchInitAttribute(int priority)
		{
			Priority = priority;
		}
	}
	public static class Paths
	{
		public static string JotunnFolder
		{
			get
			{
				string saveDataPath = Utils.GetSaveDataPath((FileSource)1);
				return Path.Combine(saveDataPath, "Jotunn");
			}
		}

		public static string CustomItemDataFolder => Path.Combine(JotunnFolder, "CustomItemData");

		public static string LanguageTranslationsFolder => Paths.PluginPath;

		public static string IconCachePath => Path.Combine(JotunnFolder, "CachedIcons");
	}
	internal static class PieceUtils
	{
		public static PieceCategory VanillaMaxPieceCategory { get; } = GetVanillaPieceCategory("Max", (PieceCategory)8);

		public static PieceCategory VanillaAllPieceCategory { get; } = GetVanillaPieceCategory("All", (PieceCategory)100);

		private static PieceCategory GetVanillaPieceCategory(string name, PieceCategory fallback)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return (PieceCategory)Enum.Parse(typeof(PieceCategory), name);
			}
			catch (Exception)
			{
				Logger.LogWarning($"Could not find Piece.PieceCategory {name}, using fallback value {fallback}");
				return fallback;
			}
		}
	}
	public static class ReflectionHelper
	{
		public static class Cache
		{
			private static MethodInfo _enumerableToArray;

			private static MethodInfo _enumerableToList;

			private static MethodInfo _enumerableCast;

			public static MethodInfo EnumerableToArray
			{
				get
				{
					if (_enumerableToArray == null)
					{
						_enumerableToArray = typeof(Enumerable).GetMethod("ToArray", (BindingFlags)(-1));
					}
					return _enumerableToArray;
				}
			}

			public static MethodInfo EnumerableToList
			{
				get
				{
					if (_enumerableToList == null)
					{
						_enumerableToList = typeof(Enumerable).GetMethod("ToList", (BindingFlags)(-1));
					}
					return _enumerableToList;
				}
			}

			public static MethodInfo EnumerableCast
			{
				get
				{
					if (_enumerableCast == null)
					{
						_enumerableCast = typeof(Enumerable).GetMethod("Cast", (BindingFlags)(-1));
					}
					return _enumerableCast;
				}
			}
		}

		public const BindingFlags AllBindingFlags = (BindingFlags)(-1);

		public static bool IsSameOrSubclass(this Type type, Type @base)
		{
			if (!type.IsSubclassOf(@base))
			{
				return type == @base;
			}
			return true;
		}

		public static bool HasImplementedRawGeneric(this Type type, Type generic)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (generic == null)
			{
				throw new ArgumentNullException("generic");
			}
			if (type.GetInterfaces().Any(IsTheRawGenericType))
			{
				return true;
			}
			while (type != null && type != typeof(object))
			{
				if (IsTheRawGenericType(type))
				{
					return true;
				}
				type = type.BaseType;
			}
			return false;
			bool IsTheRawGenericType(Type test)
			{
				return generic == (test.IsGenericType ? test.GetGenericTypeDefinition() : test);
			}
		}

		public static bool IsEnumerable(this Type type)
		{
			if (typeof(IEnumerable).IsAssignableFrom(type))
			{
				return type != typeof(string);
			}
			return false;
		}

		public static Type GetEnumeratedType(this Type type)
		{
			object obj = type?.GetElementType();
			if (obj == null)
			{
				if (!typeof(IEnumerable).IsAssignableFrom(type))
				{
					return null;
				}
				obj = type.GetGenericArguments().FirstOrDefault();
			}
			return (Type)obj;
		}

		public static Type GetCallingType()
		{
			return (new StackTrace().GetFrames() ?? Array.Empty<StackFrame>()).First((StackFrame x) => x.GetMethod().ReflectedType?.Assembly != typeof(Main).Assembly).GetMethod().ReflectedType;
		}

		public static Assembly GetCallingAssembly()
		{
			return (new StackTrace().GetFrames() ?? Array.Empty<StackFrame>()).First((StackFrame x) => x.GetMethod().ReflectedType?.Assembly != typeof(Main).Assembly).GetMethod().ReflectedType?.Assembly;
		}

		public static object InvokePrivate(object instance, string name, object[] args = null)
		{
			MethodInfo method = instance.GetType().GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic);
			if (method == null)
			{
				Type[] types = ((args == null) ? Type.EmptyTypes : args.Select((object arg) => arg.GetType()).ToArray());
				method = instance.GetType().GetMethod(name, types);
			}
			if (method == null)
			{
				Logger.LogError("Method " + name + " does not exist on type: " + instance.GetType());
				return null;
			}
			return method.Invoke(instance, args);
		}

		public static T GetPrivateProperty<T>(object instance, string name)
		{
			PropertyInfo property = instance.GetType().GetProperty(name, BindingFlags.Instance | BindingFlags.NonPublic);
			if (property == null)
			{
				Logger.LogError("Property " + name + " does not exist on type: " + instance.GetType());
				return default(T);
			}
			return (T)property.GetValue(instance);
		}

		public static T GetPrivateField<T>(object instance, string name)
		{
			FieldInfo field = instance.GetType().GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				Logger.LogError("Variable " + name + " does not exist on type: " + instance.GetType());
				return default(T);
			}
			return (T)field.GetValue(instance);
		}

		public static T GetPrivateField<T>(Type type, string name)
		{
			FieldInfo field = type.GetField(name, BindingFlags.Static | BindingFlags.NonPublic);
			if (field == null)
			{
				Logger.LogError("Variable " + name + " does not exist on type: " + type);
				return default(T);
			}
			return (T)field.GetValue(null);
		}

		public static void SetPrivateField(object instance, string name, object value)
		{
			FieldInfo field = instance.GetType().GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				Logger.LogError("Variable " + name + " does not exist on type: " + instance.GetType());
			}
			else
			{
				field.SetValue(instance, value);
			}
		}
	}
	public static class ShaderHelper
	{
		public static List<Renderer> GetRenderers(GameObject gameObject)
		{
			List<Renderer> list = new List<Renderer>();
			list.AddRange((IEnumerable<Renderer>)(object)gameObject.GetComponentsInChildren<MeshRenderer>(true));
			list.AddRange((IEnumerable<Renderer>)(object)gameObject.GetComponentsInChildren<SkinnedMeshRenderer>(true));
			return list;
		}

		public static List<Material> GetRendererMaterials(GameObject gameObject)
		{
			List<Material> list = new List<Material>();
			foreach (Renderer renderer in GetRenderers(gameObject))
			{
				list.AddRange(renderer.materials);
			}
			return list;
		}

		public static List<Material> GetRendererSharedMaterials(GameObject gameObject)
		{
			List<Material> list = new List<Material>();
			foreach (Renderer renderer in GetRenderers(gameObject))
			{
				list.AddRange(renderer.sharedMaterials);
			}
			return list;
		}

		public static List<Material> GetAllRendererMaterials(GameObject gameObject)
		{
			List<Material> list = new List<Material>();
			foreach (Renderer renderer in GetRenderers(gameObject))
			{
				list.AddRange(renderer.materials);
				list.AddRange(renderer.sharedMaterials);
			}
			return list;
		}

		public static Texture2D CreateScaledTexture(Texture2D texture, int width)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			Texture2D val = new Texture2D(((Texture)texture).width, ((Texture)texture).height, texture.format, false);
			val.SetPixels(texture.GetPixels());
			val.Apply();
			ScaleTexture(val, width);
			return val;
		}

		public static void ScaleTexture(Texture2D texture, int width)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(((Texture)texture).width, ((Texture)texture).height, texture.format, false);
			val.SetPixels(texture.GetPixels());
			val.Apply();
			int num = (int)Math.Round((float)width * (float)((Texture)texture).height / (float)((Texture)texture).width);
			texture.Reinitialize(width, num);
			texture.Apply();
			Color[] pixels = texture.GetPixels(0);
			float num2 = 1f / (float)width;
			float num3 = 1f / (float)num;
			for (int i = 0; i < pixels.Length; i++)
			{
				pixels[i] = val.GetPixelBilinear(num2 * ((float)i % (float)width), num3 * Mathf.Floor((float)i / (float)width));
			}
			texture.SetPixels(pixels, 0);
			texture.Apply();
			Object.Destroy((Object)(object)val);
		}

		public static void ShaderDump(GameObject gameObject)
		{
			List<Material> rendererMaterials = GetRendererMaterials(gameObject);
			foreach (Material item in rendererMaterials)
			{
				Logger.LogDebug(((object)item.shader).ToString());
				string[] shaderKeywords = item.shaderKeywords;
				foreach (string data in shaderKeywords)
				{
					Logger.LogDebug(data);
				}
				string[] texturePropertyNames = item.GetTexturePropertyNames();
				foreach (string data2 in texturePropertyNames)
				{
					Logger.LogDebug(data2);
				}
				for (int k = 0; k < item.shader.GetPropertyCount(); k++)
				{
					Logger.LogDebug(item.shader.GetPropertyName(k));
				}
			}
		}
	}
	public class SyncingConfigurationEventArgs : EventArgs
	{
	}
	public static class UndoActions
	{
		private static class UndoHelper
		{
			private static Dictionary<ZDO, BinarySearchDictionary<int, float>> clonedFloats = new Dictionary<ZDO, BinarySearchDictionary<int, float>>();

			private static Dictionary<ZDO, BinarySearchDictionary<int, Vector3>> clonedVec3 = new Dictionary<ZDO, BinarySearchDictionary<int, Vector3>>();

			private static Dictionary<ZDO, BinarySearchDictionary<int, Quaternion>> clonedQuats = new Dictionary<ZDO, BinarySearchDictionary<int, Quaternion>>();

			private static Dictionary<ZDO, BinarySearchDictionary<int, int>> clonedInts = new Dictionary<ZDO, BinarySearchDictionary<int, int>>();

			private static Dictionary<ZDO, BinarySearchDictionary<int, long>> clonedLongs = new Dictionary<ZDO, BinarySearchDictionary<int, long>>();

			private static Dictionary<ZDO, BinarySearchDictionary<int, string>> clonedStrings = new Dictionary<ZDO, BinarySearchDictionary<int, string>>();

			private static Dictionary<ZDO, BinarySearchDictionary<int, byte[]>> clonedByteArrays = new Dictionary<ZDO, BinarySearchDictionary<int, byte[]>>();

			public static void CopyData(ZDO from, ZDO to)
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				bool flag = to.m_prefab != from.m_prefab;
				to.m_prefab = from.m_prefab;
				to.m_position = from.m_position;
				to.m_rotation = from.m_rotation;
				ApplyZDOExtraData(to.m_uid, from);
				ZNetScene instance = ZNetScene.instance;
				if (instance.m_instances.TryGetValue(to, out var value))
				{
					Transform transform = ((Component)value).transform;
					transform.position = from.m_position;
					transform.rotation = Quaternion.Euler(from.m_rotation);
					transform.localScale = from.GetVec3("scale", Vector3.one);
					if (flag)
					{
						GameObject val = ZNetScene.instance.CreateObject(to);
						if (Object.op_Implicit((Object)(object)val))
						{
							Object.Destroy((Object)(object)((Component)value).gameObject);
							ZNetScene.instance.m_instances[to] = val.GetComponent<ZNetView>();
						}
					}
				}
				to.IncreaseDataRevision();
			}

			public static void ApplyZDOExtraData(ZDOID id, ZDO zdo)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				ZDOExtraData.s_floats[id] = CloneBinarySearchDictionary<int, float>(clonedFloats[zdo]);
				ZDOExtraData.s_vec3[id] = CloneBinarySearchDictionary<int, Vector3>(clonedVec3[zdo]);
				ZDOExtraData.s_quats[id] = CloneBinarySearchDictionary<int, Quaternion>(clonedQuats[zdo]);
				ZDOExtraData.s_ints[id] = CloneBinarySearchDictionary<int, int>(clonedInts[zdo]);
				ZDOExtraData.s_longs[id] = CloneBinarySearchDictionary<int, long>(clonedLongs[zdo]);
				ZDOExtraData.s_strings[id] = CloneBinarySearchDictionary<int, string>(clonedStrings[zdo]);
				ZDOExtraData.s_byteArrays[id] = CloneBinarySearchDictionary<int, byte[]>(clonedByteArrays[zdo]);
			}

			public static ZDO Place(ZDO zdo)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				GameObject prefab = ZNetScene.instance.GetPrefab(zdo.GetPrefab());
				if (!Object.op_Implicit((Object)(object)prefab))
				{
					throw new InvalidOperationException("Invalid prefab");
				}
				GameObject val = Object.Instantiate<GameObject>(prefab, zdo.GetPosition(), zdo.GetRotation());
				ZNetView component = val.GetComponent<ZNetView>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					throw new InvalidOperationException("No view");
				}
				ZDO zDO = component.GetZDO();
				component.SetLocalScale(zdo.GetVec3("scale", val.transform.localScale));
				CopyData(zdo, zDO);
				return zDO;
			}

			public static ZDO[] Place(ZDO[] data)
			{
				return (from obj in data.Select(Place)
					where obj != null
					select obj).ToArray();
			}

			public static string Name(ZDO zdo)
			{
				return Utils.GetPrefabName(ZNetScene.instance.GetPrefab(zdo.GetPrefab()));
			}

			public static string Print(ZDO[] data)
			{
				if (data.Length == 1)
				{
					return Name(data.First());
				}
				IEnumerable<IGrouping<string, ZDO>> enumerable = data.GroupBy(Name);
				IGrouping<string, ZDO>[] array = (enumerable as IGrouping<string, ZDO>[]) ?? enumerable.ToArray();
				if (array.Length == 1)
				{
					return $"{array.First().Key} {array.First().Count()}x";
				}
				return $" objects {data.Length}x";
			}

			public static ZDO[] Remove(ZDO[] toRemove)
			{
				ZDO[] result = Clone(toRemove);
				foreach (ZDO zdo in toRemove)
				{
					RemoveZDO(zdo);
				}
				return result;
			}

			public static ZDO[] Clone(IEnumerable<ZDO> data)
			{
				return data.Select(CloneZDO).ToArray();
			}

			private static ZDO CloneZDO(ZDO zdo)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
				ZDO val = zdo.Clone();
				val.SaveClone = false;
				clonedFloats[val] = CloneBinarySearchDictionary(val.m_uid, ZDOExtraData.s_floats);
				clonedVec3[val] = CloneBinarySearchDictionary(val.m_uid, ZDOExtraData.s_vec3);
				clonedQuats[val] = CloneBinarySearchDictionary(val.m_uid, ZDOExtraData.s_quats);
				clonedInts[val] = CloneBinarySearchDictionary(val.m_uid, ZDOExtraData.s_ints);
				clonedLongs[val] = CloneBinarySearchDictionary(val.m_uid, ZDOExtraData.s_longs);
				clonedStrings[val] = CloneBinarySearchDictionary(val.m_uid, ZDOExtraData.s_strings);
				clonedByteArrays[val] = CloneBinarySearchDictionary(val.m_uid, ZDOExtraData.s_byteArrays);
				return val;
			}

			public static void RemoveZDO(ZDO zdo)
			{
				if (IsValid(zdo))
				{
					if (!zdo.IsOwner())
					{
						zdo.SetOwner(ZDOMan.GetSessionID());
					}
					if (ZNetScene.instance.m_instances.TryGetValue(zdo, out var value))
					{
						ZNetScene.instance.Destroy(((Component)value).gameObject);
					}
					else
					{
						ZDOMan.instance.DestroyZDO(zdo);
					}
				}
			}

			public static bool IsValid(ZNetView view)
			{
				if (Object.op_Implicit((Object)(object)view))
				{
					return IsValid(view.GetZDO());
				}
				return false;
			}

			public static bool IsValid(ZDO zdo)
			{
				if (zdo != null)
				{
					return zdo.IsValid();
				}
				return false;
			}

			public static void ApplyData(Dictionary<Vector3, TerrainUndoData> data, Vector3 pos, float radius)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				foreach (KeyValuePair<Vector3, TerrainUndoData> datum in data)
				{
					TerrainComp val = TerrainComp.FindTerrainCompiler(datum.Key);
					if (Object.op_Implicit((Object)(object)val))
					{
						HeightUndoData[] heights = datum.Value.Heights;
						foreach (HeightUndoData heightUndoData in heights)
						{
							val.m_smoothDelta[heightUndoData.Index] = heightUndoData.Smooth;
							val.m_levelDelta[heightUndoData.Index] = heightUndoData.Level;
							val.m_modifiedHeight[heightUndoData.Index] = heightUndoData.HeightModified;
						}
						PaintUndoData[] paints = datum.Value.Paints;
						foreach (PaintUndoData paintUndoData in paints)
						{
							val.m_modifiedPaint[paintUndoData.Index] = paintUndoData.PaintModified;
							val.m_paintMask[paintUndoData.Index] = paintUndoData.Paint;
						}
						Save(val);
					}
				}
				ClutterSystem instance = ClutterSystem.instance;
				if (instance != null)
				{
					instance.ResetGrass(pos, radius);
				}
			}

			public static void Save(TerrainComp compiler)
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				ZNetView component = ((Component)compiler).GetComponent<ZNetView>();
				if (component != null)
				{
					component.ClaimOwnership();
				}
				compiler.m_operations++;
				compiler.m_lastOpPoint = Vector3.zero;
				compiler.m_lastOpRadius = 0f;
				compiler.Save();
				compiler.m_hmap.Poke(false);
			}

			public static BinarySearchDictionary<TKey, TValue> CloneBinarySearchDictionary<TKey, TValue>(BinarySearchDictionary<TKey, TValue> dict) where TKey : IComparable<TKey>
			{
				return dict.Clone() as BinarySearchDictionary<TKey, TValue>;
			}

			public static BinarySearchDictionary<TKey, TValue> CloneBinarySearchDictionary<TKey, TValue>(ZDOID id, Dictionary<ZDOID, BinarySearchDictionary<TKey, TValue>> dict) where TKey : IComparable<TKey>
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return CloneBinarySearchDictionary<TKey, TValue>(ZDOHelper.GetValueOrDefaultPiktiv<ZDOID, BinarySearchDictionary<TKey, TValue>>((IDictionary<ZDOID, BinarySearchDictionary<TKey, TValue>>)dict, id, new BinarySearchDictionary<TKey, TValue>()));
			}
		}

		public class UndoCreate : UndoManager.IUndoAction
		{
			public ZDO[] Data;

			public UndoCreate(IEnumerable<ZDO> data)
			{
				Data = UndoHelper.Clone(data);
			}

			public string Description()
			{
				return "Created " + UndoHelper.Print(Data);
			}

			public virtual void Undo()
			{
				Data = UndoHelper.Remove(Data);
			}

			public string UndoMessage()
			{
				return "Undo: Removed " + UndoHelper.Print(Data);
			}

			public virtual void Redo()
			{
				Data = UndoHelper.Place(Data);
			}

			public string RedoMessage()
			{
				return "Redo: Restored " + UndoHelper.Print(Data);
			}
		}

		public class UndoRemove : UndoManager.IUndoAction
		{
			public ZDO[] Data;

			public UndoRemove(IEnumerable<ZDO> data)
			{
				Data = UndoHelper.Clone(data);
			}

			public string Description()
			{
				return "Removed " + UndoHelper.Print(Data);
			}

			public virtual void Undo()
			{
				Data = UndoHelper.Place(Data);
			}

			public string UndoMessage()
			{
				return "Undo: Restored " + UndoHelper.Print(Data);
			}

			public virtual void Redo()
			{
				Data = UndoHelper.Remove(Data);
			}

			public string RedoMessage()
			{
				return "Redo: Removed " + UndoHelper.Print(Data);
			}
		}

		public class HeightUndoData
		{
			public float Smooth;

			public float Level;

			public int Index = -1;

			public bool HeightModified;
		}

		public class PaintUndoData
		{
			public bool PaintModified;

			public Color Paint = Color.black;

			public int Index = -1;
		}

		public class TerrainUndoData
		{
			public HeightUndoData[] Heights = new HeightUndoData[0];

			public PaintUndoData[] Paints = new PaintUndoData[0];
		}

		public class UndoTerrain : UndoManager.IUndoAction
		{
			private readonly Dictionary<Vector3, TerrainUndoData> Before;

			private readonly Dictionary<Vector3, TerrainUndoData> After;

			private readonly Vector3 Position;

			private readonly float Radius;

			public UndoTerrain(Dictionary<Vector3, TerrainUndoData> before, Dictionary<Vector3, TerrainUndoData> after, Vector3 position, float radius)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				Before = before;
				After = after;
				Position = position;
				Radius = radius;
			}

			public string Description()
			{
				return "Changed terrain";
			}

			public virtual void Undo()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				UndoHelper.ApplyData(Before, Position, Radius);
			}

			public string UndoMessage()
			{
				return "Undoing terrain changes";
			}

			public virtual void Redo()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				UndoHelper.ApplyData(After, Position, Radius);
			}

			public string RedoMessage()
			{
				return "Redoing terrain changes";
			}
		}
	}
	public class WeightedList<T, ItemType> where T : WeightedItem<ItemType>
	{
		public readonly List<T> List;

		public WeightedList()
		{
			List = new List<T>();
		}

		public void Add(T item)
		{
			List.Add(item);
		}

		public bool Remove(T item)
		{
			return List.Remove(item);
		}

		public ItemType GetRandomItem(List<T> list = null)
		{
			if (list == null)
			{
				list = List;
			}
			float num = 0f;
			foreach (T item in list)
			{
				num += item.Weight;
			}
			float num2 = Random.Range(0f, num - 1f);
			foreach (T item2 in list)
			{
				if (num2 < item2.Weight)
				{
					return item2.Item;
				}
				num2 -= item2.Weight;
			}
			throw new Exception("No item in weighted list");
		}
	}
	public class WeightedItem<T>
	{
		public T Item { get; private set; }

		public virtual float Weight { get; set; }

		public WeightedItem(T item, float weight = 0f)
		{
			Item = item;
			if (weight != 0f)
			{
				Weight = weight;
			}
		}
	}
}
namespace Jotunn.GUI
{
	public class ColorPicker : MonoBehaviour
	{
		public delegate void ColorEvent(Color c);

		private sealed class HSV
		{
			public double H;

			public double S = 1.0;

			public double V = 1.0;

			public byte A = byte.MaxValue;

			public HSV()
			{
			}

			public HSV(double h, double s, double v)
			{
				H = h;
				S = s;
				V = v;
			}

			public HSV(Color color)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: 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)
				float num = Mathf.Max(color.r, Mathf.Max(color.g, color.b));
				float num2 = Mathf.Min(color.r, Mathf.Min(color.g, color.b));
				float num3 = (float)H;
				if (num2 != num)
				{
					num3 = ((num == color.r) ? ((color.g - color.b) / (num - num2)) : ((num != color.g) ? (4f + (color.r - color.g) / (num - num2)) : (2f + (color.b - color.r) / (num - num2)))) * 60f;
					if (num3 < 0f)
					{
						num3 += 360f;
					}
				}
				H = num3;
				S = ((num == 0f) ? 0.0 : (1.0 - (double)num2 / (double)num));
				V = num;
				A = (byte)(color.a * 255f);
			}

			public Color32 ToColor()
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				int num = Convert.ToInt32(Math.Floor(H / 60.0)) % 6;
				double num2 = H / 60.0 - Math.Floor(H / 60.0);
				double num3 = V * 255.0;
				byte b = (byte)Convert.ToInt32(num3);
				byte b2 = (byte)Convert.ToInt32(num3 * (1.0 - S));
				byte b3 = (byte)Convert.ToInt32(num3 * (1.0 - num2 * S));
				byte b4 = (byte)Convert.ToInt32(num3 * (1.0 - (1.0 - num2) * S));
				return (Color32)(num switch
				{
					0 => new Color32(b, b4, b2, A), 
					1 => new Color32(b3, b, b2, A), 
					2 => new Color32(b2, b, b4, A), 
					3 => new Color32(b2, b3, b, A), 
					4 => new Color32(b4, b2, b, A), 
					5 => new Color32(b, b2, b3, A), 
					_ => default(Color32), 
				});
			}
		}

		private static ColorPicker instance;

		public static bool done = true;

		private static ColorEvent onCC;

		private static ColorEvent onCS;

		private static Color32 originalColor;

		private static Color32 modifiedColor;

		private static HSV modifiedHsv;

		private static bool useA;

		private bool interact;

		public RectTransform positionIndicator;

		public Slider mainComponent;

		public Slider rComponent;

		public Slider gComponent;

		public Slider bComponent;

		public Slider aComponent;

		public InputField hexaComponent;

		public RawImage colorComponent;

		private void Awake()
		{
			instance = this;
			((Component)this).gameObject.SetActive(false);
		}

		public static bool Create(Color original, string message, ColorEvent onColorChanged, ColorEvent onColorSelected, bool useAlpha = false)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (instance == null)
			{
				Debug.LogError((object)"No Colorpicker prefab active on 'Start' in scene");
				return false;
			}
			if (done)
			{
				done = false;
				originalColor = Color32.op_Implicit(original);
				modifiedColor = Color32.op_Implicit(original);
				onCC = onColorChanged;
				onCS = onColorSelected;
				useA = useAlpha;
				((Component)instance).gameObject.SetActive(true);
				((Component)((Component)instance).transform.GetChild(0)).GetComponent<Text>().text = message;
				((Component)instance.aComponent).gameObject.SetActive(useAlpha);
				instance.RecalculateMenu(recalculateHSV: true);
				((Component)instance.hexaComponent.placeholder).GetComponent<Text>().text = "RRGGBB" + (useAlpha ? "AA" : "");
				return true;
			}
			Done();
			return false;
		}

		private void RecalculateMenu(bool recalculateHSV)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			interact = false;
			if (recalculateHSV)
			{
				modifiedHsv = new HSV(Color32.op_Implicit(modifiedColor));
			}
			else
			{
				modifiedColor = modifiedHsv.ToColor();
			}
			rComponent.value = (int)modifiedColor.r;
			((Component)((Component)rComponent).transform.GetChild(3)).GetComponent<InputField>().text = modifiedColor.r.ToString();
			gComponent.value = (int)modifiedColor.g;
			((Component)((Component)gComponent).transform.GetChild(3)).GetComponent<InputField>().text = modifiedColor.g.ToString();
			bComponent.value = (int)modifiedColor.b;
			((Component)((Component)bComponent).transform.GetChild(3)).GetComponent<InputField>().text = modifiedColor.b.ToString();
			if (useA)
			{
				aComponent.value = (int)modifiedColor.a;
				((Component)((Component)aComponent).transform.GetChild(3)).GetComponent<InputField>().text = modifiedColor.a.ToString();
			}
			mainComponent.value = (float)modifiedHsv.H;
			((Graphic)((Component)((Component)rComponent).transform.GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(byte.MaxValue, modifiedColor.g, modifiedColor.b, byte.MaxValue));
			((Graphic)((Component)((Component)rComponent).transform.GetChild(0).GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32((byte)0, modifiedColor.g, modifiedColor.b, byte.MaxValue));
			((Graphic)((Component)((Component)gComponent).transform.GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(modifiedColor.r, byte.MaxValue, modifiedColor.b, byte.MaxValue));
			((Graphic)((Component)((Component)gComponent).transform.GetChild(0).GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(modifiedColor.r, (byte)0, modifiedColor.b, byte.MaxValue));
			((Graphic)((Component)((Component)bComponent).transform.GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(modifiedColor.r, modifiedColor.g, byte.MaxValue, byte.MaxValue));
			((Graphic)((Component)((Component)bComponent).transform.GetChild(0).GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(modifiedColor.r, modifiedColor.g, (byte)0, byte.MaxValue));
			if (useA)
			{
				((Graphic)((Component)((Component)aComponent).transform.GetChild(0).GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(modifiedColor.r, modifiedColor.g, modifiedColor.b, byte.MaxValue));
			}
			((Graphic)((Component)((Transform)positionIndicator).parent.GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new HSV(modifiedHsv.H, 1.0, 1.0).ToColor());
			positionIndicator.anchorMin = new Vector2((float)modifiedHsv.S, (float)modifiedHsv.V);
			positionIndicator.anchorMax = positionIndicator.anchorMin;
			hexaComponent.text = (useA ? ColorUtility.ToHtmlStringRGBA(Color32.op_Implicit(modifiedColor)) : ColorUtility.ToHtmlStringRGB(Color32.op_Implicit(modifiedColor)));
			((Graphic)colorComponent).color = Color32.op_Implicit(modifiedColor);
			onCC?.Invoke(Color32.op_Implicit(modifiedColor));
			interact = true;
		}

		public void SetChooser()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Transform)positionIndicator).parent;
			Vector2 val = default(Vector2);
			RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)(object)((parent is RectTransform) ? parent : null), Vector2.op_Implicit(Input.mousePosition), ((Component)this).GetComponentInParent<Canvas>().worldCamera, ref val);
			Transform parent2 = ((Transform)positionIndicator).parent;
			val = Rect.PointToNormalized(((RectTransform)((parent2 is RectTransform) ? parent2 : null)).rect, val);
			if (positionIndicator.anchorMin != val)
			{
				positionIndicator.anchorMin = val;
				positionIndicator.anchorMax = val;
				modifiedHsv.S = val.x;
				modifiedHsv.V = val.y;
				RecalculateMenu(recalculateHSV: false);
			}
		}

		public void SetMain(float value)
		{
			if (interact)
			{
				modifiedHsv.H = value;
				RecalculateMenu(recalculateHSV: false);
			}
		}

		public void SetR(float value)
		{
			if (interact)
			{
				modifiedColor.r = (byte)value;
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetR(string value)
		{
			if (interact)
			{
				modifiedColor.r = (byte)Mathf.Clamp(int.Parse(value), 0, 255);
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetG(float value)
		{
			if (interact)
			{
				modifiedColor.g = (byte)value;
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetG(string value)
		{
			if (interact)
			{
				modifiedColor.g = (byte)Mathf.Clamp(int.Parse(value), 0, 255);
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetB(float value)
		{
			if (interact)
			{
				modifiedColor.b = (byte)value;
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetB(string value)
		{
			if (interact)
			{
				modifiedColor.b = (byte)Mathf.Clamp(int.Parse(value), 0, 255);
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetA(float value)
		{
			if (interact)
			{
				modifiedHsv.A = (byte)value;
				RecalculateMenu(recalculateHSV: false);
			}
		}

		public void SetA(string value)
		{
			if (interact)
			{
				modifiedHsv.A = (byte)Mathf.Clamp(int.Parse(value), 0, 255);
				RecalculateMenu(recalculateHSV: false);
			}
		}

		public void SetHexa(string value)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!interact)
			{
				return;
			}
			Color val = default(Color);
			if (ColorUtility.TryParseHtmlString("#" + value, ref val))
			{
				if (!useA)
				{
					val.a = 1f;
				}
				modifiedColor = Color32.op_Implicit(val);
				RecalculateMenu(recalculateHSV: true);
			}
			else
			{
				hexaComponent.text = (useA ? ColorUtility.ToHtmlStringRGBA(Color32.op_Implicit(modifiedColor)) : ColorUtility.ToHtmlStringRGB(Color32.op_Implicit(modifiedColor)));
			}
		}

		public void CCancel()
		{
			Cancel();
		}

		public static void Cancel()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			modifiedColor = originalColor;
			Done();
		}

		public void CDone()
		{
			Done();
		}

		public static void Done()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			done = true;
			onCC?.Invoke(Color32.op_Implicit(modifiedColor));
			onCS?.Invoke(Color32.op_Implicit(modifiedColor));
			((Component)((Component)instance).transform).gameObject.SetActive(false);
		}
	}
	public class DragWindowCntrl : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler
	{
		private RectTransform window;

		private Vector2 delta;

		[Obsolete("Use gameObject.AddComponent<DragWindowCntrl>() instead")]
		public static void ApplyDragWindowCntrl(GameObject go)
		{
			go.AddComponent<DragWindowCntrl>();
		}

		private void Awake()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			window = (RectTransform)((Component)this).transform;
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			delta = Vector2.op_Implicit(Input.mousePosition - ((Transform)window).position);
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = eventData.position - delta;
			Rect rect = window.rect;
			Vector2 val2 = Vector2.op_Implicit(((Transform)window).lossyScale);
			float num = ((Rect)(ref rect)).width / 2f * val2.x;
			float num2 = (float)Screen.width - num;
			float num3 = ((Rect)(ref rect)).height / 2f * val2.y;
			float num4 = (float)Screen.height - num3;
			val.x = Mathf.Clamp(val.x, num, num2);
			val.y = Mathf.Clamp(val.y, num3, num4);
			((Component)this).transform.position = Vector2.op_Implicit(val);
		}
	}
	public class GradientPicker : MonoBehaviour
	{
		public delegate void GradientEvent(Gradient g);

		private static GradientPicker instance;

		public static bool done = true;

		private static GradientEvent onGC;

		private static GradientEvent onGS;

		private static Gradient originalGradient;

		private static Gradient modifiedGradient;

		private GameObject key;

		private static bool interact;

		private InputField positionComponent;

		private Image colorComponent;

		private Transform alphaComponent;

		private List<Slider> colorKeyObjects;

		private List<GradientColorKey> colorKeys;

		private int selectedColorKey;

		private List<Slider> alphaKeyObjects;

		private List<GradientAlphaKey> alphaKeys;

		private int selectedAlphaKey;

		private void Awake()
		{
			instance = this;
			key = ((Component)((Component)this).transform.GetChild(2)).gameObject;
			positionComponent = ((Component)((Component)this).transform.parent.GetChild(3)).GetComponent<InputField>();
			colorComponent = ((Component)((Component)this).transform.parent.GetChild(4)).GetComponent<Image>();
			alphaComponent = ((Component)this).transform.parent.GetChild(5);
			((Component)((Component)this).transform.parent).gameObject.SetActive(false);
		}

		public static bool Create(Gradient original, string message, GradientEvent onGradientChanged, GradientEvent onGradientSelected)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			if (instance == null)
			{
				Debug.LogError((object)"No Gradientpicker prefab active on 'Start' in scene");
				return false;
			}
			if (done)
			{
				done = false;
				originalGradient = new Gradient();
				originalGradient.SetKeys(original.colorKeys, original.alphaKeys);
				modifiedGradient = new Gradient();
				modifiedGradient.SetKeys(original.colorKeys, original.alphaKeys);
				onGC = onGradientChanged;
				onGS = onGradientSelected;
				((Component)((Component)instance).transform.parent).gameObject.SetActive(true);
				((Component)((Component)instance).transform.parent.GetChild(0)).GetComponent<Text>().text = message;
				instance.Setup();
				return true;
			}
			Done();
			return false;
		}

		private void Setup()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			interact = false;
			colorKeyObjects = new List<Slider>();
			colorKeys = new List<GradientColorKey>();
			alphaKeyObjects = new List<Slider>();
			alphaKeys = new List<GradientAlphaKey>();
			GradientColorKey[] array = originalGradient.colorKeys;
			foreach (GradientColorKey k in array)
			{
				CreateColorKey(k);
			}
			GradientAlphaKey[] array2 = originalGradient.alphaKeys;
			foreach (GradientAlphaKey k2 in array2)
			{
				CreateAlphaKey(k2);
			}
			CalculateTexture();
			interact = true;
		}

		private void CreateColorKey(GradientColorKey k)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (colorKeys.Count < 8)
			{
				Slider component = Object.Instantiate<GameObject>(key, ((Component)this).transform.position, default(Quaternion), ((Component)this).transform).GetComponent<Slider>();
				((RectTransform)((Component)component).transform).anchoredPosition = new Vector2(0f, -29f);
				((Object)component).name = "ColorKey";
				((Component)component).gameObject.SetActive(true);
				component.value = k.time;
				((Graphic)((Component)((Component)component).transform.GetChild(0).GetChild(0).GetChild(0)).GetComponent<Image>()).color = k.color;
				colorKeyObjects.Add(component);
				colorKeys.Add(k);
				ChangeSelectedColorKey(colorKeys.Count - 1);
			}
		}

		public void CreateNewColorKey(float time)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetMouseButtonDown(0))
			{
				interact = false;
				CreateColorKey(new GradientColorKey(modifiedGradient.Evaluate(time), time));
				interact = true;
			}
		}

		private void CreateAlphaKey(GradientAlphaKey k)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if (alphaKeys.Count < 8)
			{
				Slider component = Object.Instantiate<GameObject>(key, ((Component)this).transform.position, default(Quaternion), ((Component)this).transform).GetComponent<Slider>();
				((RectTransform)((Component)component).transform).anchoredPosition = new Vector2(0f, 25f);
				((Component)component).transform.GetChild(0).GetChild(0).rotation = default(Quaternion);
				((Object)component).name = "AlphaKey";
				((Component)component).gameObject.SetActive(true);
				component.value = k.time;
				((Graphic)((Component)((Component)component).transform.GetChild(0).GetChild(0).GetChild(0)).GetComponent<Image>()).color = new Color(k.alpha, k.alpha, k.alpha, 1f);
				alphaKeyObjects.Add(component);
				alphaKeys.Add(k);
				ChangeSelectedAlphaKey(alphaKeys.Count - 1);
			}
		}

		public void CreateNewAlphaKey(float time)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetMouseButtonDown(0))
			{
				interact = false;
				CreateAlphaKey(new GradientAlphaKey(modifiedGradient.Evaluate(time).a, time));
				interact = true;
			}
		}

		private void CalculateTexture()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			Color32[] array = (Color32[])(object)new Color32[325];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = Color32.op_Implicit(modifiedGradient.Evaluate((float)i / (float)array.Length));
			}
			Texture2D val = new Texture2D(array.Length, 1)
			{
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1
			};
			val.SetPixels32(array);
			val.Apply();
			((Component)this).GetComponent<RawImage>().texture = (Texture)(object)val;
			onGC?.Invoke(modifiedGradient);
		}

		public void SetAlpha(float value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (interact)
			{
				alphaKeys[selectedAlphaKey] = new GradientAlphaKey(value, alphaKeys[selectedAlphaKey].time);
				modifiedGradient.SetKeys(colorKeys.ToArray(), alphaKeys.ToArray());
				CalculateTexture();
				((Component)alphaComponent.GetChild(4)).GetComponent<InputField>().text = Mathf.RoundToInt(value * 255f).ToString();
				((Graphic)((Component)((Component)alphaKeyObjects[selectedAlphaKey]).transform.GetChild(0).GetChild(0).GetChild(0)).GetComponent<Image>()).color = new Color(value, value, value, 1f);
			}
		}

		public void SetAlpha(string value)
		{
			((Component)alphaComponent).GetComponent<Slider>().value = (float)Mathf.Clamp(int.Parse(value), 0, 255) / 255f;
			CalculateTexture();
		}

		private void ChangeSelectedColorKey(int value)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (colorKeyObjects.Count() > selectedColorKey)
			{
				((Graphic)((Component)((Component)colorKeyObjects[selectedColorKey]).transform.GetChild(0).GetChild(0)).GetComponent<Image>()).color = Color.gray;
			}
			if (alphaKeyObjects.Count() > 0)
			{
				((Graphic)((Component)((Component)alphaKeyObjects[selectedAlphaKey]).transform.GetChild(0).GetChild(0)).GetComponent<Image>()).color = Color.gray;
			}
			((Graphic)((Component)((Component)colorKeyObjects[value]).transform.GetChild(0).GetChild(0)).GetComponent<Image>()).color = Color.green;
			if (selectedColorKey != value && !ColorPicker.done)
			{
				ColorPicker.Done();
			}
			selectedColorKey = value;
			((Selectable)colorKeyObjects[value]).Select();
		}

		private void ChangeSelectedAlphaKey(int value)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (alphaKeyObjects.Count > selectedAlphaKey)
			{
				((Graphic)((Component)((Component)alphaKeyObjects[selectedAlphaKey]).transform.GetChild(0).GetChild(0)).GetComponent<Image>()).color = Color.gray;
			}
			if (colorKeyObjects.Count > 0)
			{
				((Graphic)((Component)((Component)colorKeyObjects[selectedColorKey]).transform.GetChild(0).GetChild(0)).GetComponent<Image>()).color = Color.gray;
			}
			((Graphic)((Component)((Component)alphaKeyObjects[value]).transform.GetChild(0).GetChild(0)).GetComponent<Image>()).color = Color.green;
			selectedAlphaKey = value;
			((Selectable)alphaKeyObjects[value]).Select();
		}

		public void CheckDeleteKey(Slider s)
		{
			if (!Input.GetMouseButtonDown(1))
			{
				return;
			}
			if (((Object)s).name == "ColorKey" && colorKeys.Count > 2)
			{
				if (!ColorPicker.done)
				{
					ColorPicker.Done();
					return;
				}
				int num = colorKeyObjects.IndexOf(s);
				Object.Destroy((Object)(object)((Component)colorKeyObjects[num]).gameObject);
				colorKeyObjects.RemoveAt(num);
				colorKeys.RemoveAt(num);
				if (num <= selectedColorKey)
				{
					ChangeSelectedColorKey(selectedColorKey - 1);
				}
				modifiedGradient.SetKeys(colorKeys.ToArray(), alphaKeys.ToArray());
				CalculateTexture();
			}
			if (((Object)s).name == "AlphaKey" && alphaKeys.Count > 2)
			{
				int num2 = alphaKeyObjects.IndexOf(s);
				Object.Destroy((Object)(object)((Component)alphaKeyObjects[num2]).gameObject);
				alphaKeyObjects.RemoveAt(num2);
				alphaKeys.RemoveAt(num2);
				if (num2 <= selectedAlphaKey)
				{
					ChangeSelectedAlphaKey(selectedAlphaKey - 1);
				}
				modifiedGradient.SetKeys(colorKeys.ToArray(), alphaKeys.ToArray());
				CalculateTexture();
			}
		}

		public void Select()
		{
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			Slider component = EventSystem.current.currentSelectedGameObject.GetComponent<Slider>();
			((Component)component).transform.SetAsLastSibling();
			if (((Object)component).name == "ColorKey")
			{
				ChangeSelectedColorKey(colorKeyObjects.IndexOf(component));
				((Component)alphaComponent).gameObject.SetActive(false);
				((Component)colorComponent).gameObject.SetActive(true);
				positionComponent.text = Mathf.RoundToInt(colorKeys[selectedColorKey].time * 100f).ToString();
				((Graphic)((Component)colorComponent).GetComponent<Image>()).color = colorKeys[selectedColorKey].color;
			}
			else
			{
				ChangeSelectedAlphaKey(alphaKeyObjects.IndexOf(component));
				((Component)colorComponent).gameObject.SetActive(false);
				((Component)alphaComponent).gameObject.SetActive(true);
				positionComponent.text = Mathf.RoundToInt(alphaKeys[selectedAlphaKey].time * 100f).ToString();
				((Component)alphaComponent).GetComponent<Slider>().value = alphaKeys[selectedAlphaKey].alpha;
				((Component)alphaComponent.GetChild(4)).GetComponent<InputField>().text = Mathf.RoundToInt(alphaKeys[selectedAlphaKey].alpha * 255f).ToString();
			}
		}

		public void SetTime(float time)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (interact)
			{
				Slider component = EventSystem.current.currentSelectedGameObject.GetComponent<Slider>();
				if (((Object)component).name == "ColorKey")
				{
					int index = colorKeyObjects.IndexOf(component);
					colorKeys[index] = new GradientColorKey(colorKeys[index].color, time);
				}
				else
				{
					int index2 = alphaKeyObjects.IndexOf(component);
					alphaKeys[index2] = new GradientAlphaKey(alphaKeys[index2].alpha, time);
				}
				modifiedGradient.SetKeys(colorKeys.ToArray(), alphaKeys.ToArray());
				CalculateTexture();
				positionComponent.text = Mathf.RoundToInt(time * 100f).ToString();
			}
		}

		public void SetTime(string time)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			interact = false;
			float num = (float)Mathf.Clamp(int.Parse(time), 0, 100) * 0.01f;
			if (((Component)colorComponent).gameObject.activeSelf)
			{
				colorKeyObjects[selectedColorKey].value = num;
				colorKeys[selectedColorKey] = new GradientColorKey(colorKeys[selectedColorKey].color, num);
			}
			else
			{
				alphaKeyObjects[selectedAlphaKey].value = num;
				alphaKeys[selectedAlphaKey] = new GradientAlphaKey(alphaKeys[selectedAlphaKey].alpha, num);
			}
			modifiedGradient.SetKeys(colorKeys.ToArray(), alphaKeys.ToArray());
			CalculateTexture();
			interact = true;
		}

		public void ChooseColor()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			ColorPicker.Create(colorKeys[selectedColorKey].color, "Gradient Color Key", delegate(Color c)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				UpdateColor(selectedColorKey, c);
			}, null);
		}

		private void UpdateColor(int index, Color c)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			interact = false;
			colorKeys[index] = new GradientColorKey(c, colorKeys[index].time);
			((Graphic)((Component)((Component)colorKeyObjects[index]).transform.GetChild(0).GetChild(0).GetChild(0)).GetComponent<Image>()).color = c;
			((Graphic)colorComponent).color = c;
			modifiedGradient.SetKeys(colorKeys.ToArray(), alphaKeys.ToArray());
			CalculateTexture();
			interact = true;
		}

		public void CCancel()
		{
			Cancel();
		}

		public static void Cancel()
		{
			modifiedGradient = originalGradient;
			Done();
		}

		public void CDone()
		{
			Done();
		}

		public static void Done()
		{
			if (!ColorPicker.done)
			{
				ColorPicker.Done();
			}
			foreach (Slider colorKeyObject in instance.colorKeyObjects)
			{
				Object.Destroy((Object)(object)((Component)colorKeyObject).gameObject);
			}
			foreach (Slider alphaKeyObject in instance.alphaKeyObjects)
			{
				Object.Destroy((Object)(object)((Component)alphaKeyObject).gameObject);
			}
			instance.colorKeyObjects = null;
			instance.colorKeys = null;
			instance.alphaKeyObjects = null;
			instance.alphaKeys = null;
			done = true;
			onGC?.Invoke(modifiedGradient);
			onGS?.Invoke(modifiedGradient);
			((Component)((Component)instance).transform.parent).gameObject.SetActive(false);
		}
	}
	public class MinimapOverlayPanel : MonoBehaviour
	{
		public GameObject OverlayGroup;

		public Button Button;

		public GameObject BaseMod;

		public Text BaseModText;

		public Toggle BaseToggle;

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

		public void ToggleOverlayGroup()
		{
			OverlayGroup.SetActive(!OverlayGroup.activeSelf);
		}

		public Toggle AddOverlayToggle(string modName, string overlayName)
		{
			if (!Mods.TryGetValue(modName, out var value))
			{
				value = Object.Instantiate<GameObject>(BaseMod, OverlayGroup.transform);
				value.SetActive(true);
				((Object)value).name = modName;
				value.GetComponentInChildren<Text>().text = modName;
				Mods.Add(modName, value);
			}
			Toggle val = Object.Instantiate<Toggle>(BaseToggle, value.transform);
			((Component)val).gameObject.SetActive(true);
			((Object)((Component)val).gameObject).name = overlayName;
			((Component)val).GetComponentInChildren<Text>().text = overlayName;
			return val;
		}
	}
}
namespace Jotunn.Managers
{
	public class AssetManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(AssetBundleLoader), "OnInitCompleted")]
			[HarmonyPostfix]
			private static void AssetBundleLoader_Load(AssetBundleLoader __instance)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				foreach (KeyValuePair<AssetID, AssetRef> asset in Instance.assets)
				{
					AddAssetToBundleLoader(__instance, asset.Key, asset.Value);
				}
				AssetManager.OnSoftReferenceableAssetsReady?.SafeInvoke();
			}

			[HarmonyPatch(typeof(AssetBundleLoader), "InitializeDataSide")]
			[HarmonyPrefix]
			private static void AssetBundleLoader_InitializeDataSide(ref bool allAssetsLoadable)
			{
				allAssetsLoadable = true;
			}

			public static void AddSafe(Dictionary<string, AssetID> pathsMappedToAssetId, string key, AssetID value)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				if (key != null && !pathsMappedToAssetId.ContainsKey(key))
				{
					pathsMappedToAssetId.Add(key, value);
				}
			}

			[HarmonyPatch(typeof(AssetBundleLoader), "GetAllAssetPathsMappedToAssetID")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> AssetBundleLoader_GetAllAssetPathsMappedToAssetID(IEnumerable<CodeInstruction> instructions)
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Expected O, but got Unknown
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Expected O, but got Unknown
				MethodInfo addMethod = AccessTools.Method(typeof(Dictionary<string, AssetID>), "Add", (Type[])null, (Type[])null);
				MethodInfo methodInfo = AccessTools.Method(typeof(Patches), "AddSafe", (Type[])null, (Type[])null);
				return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.Calls(i, addMethod)), (string)null)
				}).SetInstruction(new CodeInstruction(OpCodes.Call, (object)methodInfo)).InstructionEnumeration();
			}

			[HarmonyPatch(typeof(AssetLoader), "InvokeCallbacks")]
			[HarmonyPrefix]
			private static void SwapResolvedAsset(ref AssetLoader __instance, LoadResult result)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if ((int)result == 0 && Instance.assetsToResolve.TryGetValue(__instance.m_assetID, out var value))
				{
					if (!Object.op_Implicit(__instance.m_asset))
					{
						Logger.LogWarning($"AssetLoader.m_asset == null for AssetID {__instance.m_assetID} at path {__instance.m_assetPathInBundle}, skipping mocking");
						return;
					}
					value.InstantiateAndResolveAsset(__instance.m_asset);
					__instance.m_asset = value.Asset;
				}
			}

			[HarmonyPatch(typeof(AssetLoader), "Release")]
			[HarmonyPostfix]
			private static void AssetLoader_Release(ref AssetLoader __instance)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				if (((AssetLoader)(ref __instance)).ReferenceCount == 0 && Instance.assetsToResolve.TryGetValue(__instance.m_assetID, out var value))
				{
					value.DestroyAsset();
				}
			}
		}

		private struct AssetRef
		{
			public BepInPlugin sourceMod;

			public Object asset;

			public AssetID originalID;

			public AssetRef(BepInPlugin sourceMod, Object asset, Object original)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				this.sourceMod = sourceMod;
				this.asset = asset;
				originalID = (AssetID)((Object.op_Implicit(original) && Instance.IsReady()) ? Instance.GetAssetID(((object)original).GetType(), original.name) : default(AssetID));
			}
		}

		internal class MockResolutionContext
		{
			public Object Asset { get; private set; }

			public Transform Parent { get; set; }

			public Action<Object> ResolveCallback { get; set; }

			public bool IsResolved => Object.op_Implicit(Asset);

			public MockResolutionContext(Transform parent, Action<Object> resolveCallback)
			{
				Parent = parent;
				ResolveCallback = (Action<Object>)Delegate.Combine(ResolveCallback, resolveCallback);
			}

			public void InstantiateAndResolveAsset(Object realAsset)
			{
				if (!IsResolved)
				{
					Asset = Object.Instantiate(realAsset, Parent);
					Asset.name = realAsset.name;
					Object asset = Asset;
					GameObject val = (GameObject)(object)((asset is GameObject) ? asset : null);
					if (val != null)
					{
						val.FixReferences(recursive: true);
					}
					else
					{
						((object)Asset).FixReferences();
					}
					ResolveCallback?.SafeInvoke(Asset);
				}
			}

			public void DestroyAsset()
			{
				if (Object.op_Implicit(Asset))
				{
					Object.Destroy(Asset);
				}
				Asset = null;
			}
		}

		private static AssetManager instance;

		private Dictionary<AssetID, AssetRef> assets = new Dictionary<AssetID, AssetRef>();

		private Dictionary<Type, Dictionary<string, AssetID>> mapNameToAssetID;

		private GameObject ResolvedAssetsContainer;

		private Dictionary<AssetID, MockResolutionContext> assetsToResolve = new Dictionary<AssetID, MockResolutionContext>();

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

		internal Dictionary<Type, Dictionary<string, AssetID>> MapNameToAssetID => mapNameToAssetID ?? (mapNameToAssetID = CreateNameToAssetID());

		public static event Action OnSoftReferenceableAssetsReady;

		private AssetManager()
		{
		}

		static AssetManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Main.LogInit("AssetManager");
			ResolvedAssetsContainer = new GameObject("Resolved Assets");
			ResolvedAssetsContainer.transform.parent = Main.RootObject.transform;
			ResolvedAssetsContainer.SetActive(false);
			Main.Harmony.PatchAll(typeof(Patches));
		}

		public bool IsReady()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (Runtime.s_assetLoader != null)
			{
				return ((AssetBundleLoader)Runtime.s_assetLoader).Initialized;
			}
			return false;
		}

		public AssetID AddAsset(Object asset, Object original)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			AssetID val = GenerateAssetID(asset);
			if (assets.ContainsKey(val))
			{
				return val;
			}
			AssetRef assetRef = new AssetRef(BepInExUtils.GetSourceModMetadata(), asset, original);
			assets.Add(val, assetRef);
			if (IsReady() && AssetBundleLoader.Instance != null)
			{
				AddAssetToBundleLoader(AssetBundleLoader.Instance, val, assetRef);
			}
			return val;
		}

		public AssetID AddAsset(Object asset)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return AddAsset(asset, null);
		}

		public void ResolveMocksOnLoad(AssetID assetID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ResolveMocksOnLoad(assetID, null, null);
		}

		public void ResolveMocksOnLoad(AssetID assetID, Transform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ResolveMocksOnLoad(assetID, parent, null);
		}

		public void ResolveMocksOnLoad<T>(SoftReference<T> softReference, Transform parent, Action<T> resolveCallback) where T : Object
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			ResolveMocksOnLoad(softReference.m_assetID, parent, delegate(Object asset)
			{
				resolveCallback?.Invoke((T)(object)((asset is T) ? asset : null));
			});
		}

		public void ResolveMocksOnLoad(AssetID assetID, Transform parent, Action<Object> resolveCallback)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (assetsToResolve.TryGetValue(assetID, out var value))
			{
				value.Parent = parent ?? value.Parent ?? ResolvedAssetsContainer.transform;
				MockResolutionContext mockResolutionContext = value;
				mockResolutionContext.ResolveCallback = (Action<Object>)Delegate.Combine(mockResolutionContext.ResolveCallback, resolveCallback);
			}
			else
			{
				assetsToResolve.Add(assetID, new MockResolutionContext(parent ?? ResolvedAssetsContainer.transform, resolveCallback));
			}
		}

		private static void AddAssetToBundleLoader(AssetBundleLoader assetBundleLoader, AssetID assetID, AssetRef assetRef)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			string text = "JVL_BundleWrapper_" + assetRef.asset.name;
			string text2 = assetRef.sourceMod.GUID + "/Prefabs/" + assetRef.asset.name;
			if (assetBundleLoader.m_bundleNameToLoaderIndex.ContainsKey(text))
			{
				return;
			}
			AssetLocation val = default(AssetLocation);
			((AssetLocation)(ref val))..ctor(text, text2);
			BundleLoader val2 = default(BundleLoader);
			((BundleLoader)(ref val2))..ctor(text, "");
			((BundleLoader)(ref val2)).HoldReference();
			assetBundleLoader.m_bundleNameToLoaderIndex.Add(text, assetBundleLoader.m_bundleLoaders.Length);
			assetBundleLoader.m_bundleLoaders = CollectionExtensions.AddItem<BundleLoader>((IEnumerable<BundleLoader>)assetBundleLoader.m_bundleLoaders, val2).ToArray();
			int originalBundleLoaderIndex = ((IEnumerable<AssetLoader>)assetBundleLoader.m_assetLoaders).FirstOrDefault((Func<AssetLoader, bool>)((AssetLoader l) => l.m_assetID == assetRef.originalID)).m_bundleLoaderIndex;
			if (((AssetID)(ref assetRef.originalID)).IsValid && originalBundleLoaderIndex > 0)
			{
				BundleLoader val3 = assetBundleLoader.m_bundleLoaders[originalBundleLoaderIndex];
				val2.m_bundleLoaderIndicesOfThisAndDependencies = (from i in CollectionExtensions.AddItem<int>(val3.m_bundleLoaderIndicesOfThisAndDependencies.Where((int i) => i != originalBundleLoaderIndex), assetBundleLoader.m_bundleNameToLoaderIndex[text])
					orderby i
					select i).ToArray();
			}
			else
			{
				((BundleLoader)(ref val2)).SetDependencies(Array.Empty<string>());
			}
			assetBundleLoader.m_bundleLoaders[assetBundleLoader.m_bundleNameToLoaderIndex[text]] = val2;
			AssetLoader val4 = default(AssetLoader);
			((AssetLoader)(ref val4))..ctor(assetID, val);
			val4.m_asset = assetRef.asset;
			((AssetLoader)(ref val4)).HoldReference();
			assetBundleLoader.m_assetIDToLoaderIndex.Add(assetID, assetBundleLoader.m_assetLoaders.Length);
			assetBundleLoader.m_assetLoaders = CollectionExtensions.AddItem<AssetLoader>((IEnumerable<AssetLoader>)assetBundleLoader.m_assetLoaders, val4).ToArray();
			Instance.MapNameToAssetID[((object)assetRef.asset).GetType()][assetRef.asset.name] = assetID;
		}

		public AssetID GenerateAssetID(Object asset)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			uint stableHashCode = (uint)StringExtensionMethods.GetStableHashCode(asset.name);
			return new AssetID(stableHashCode, stableHashCode, stableHashCode, stableHashCode);
		}

		public AssetID GenerateAssetID(string asset)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			uint stableHashCode = (uint)StringExtensionMethods.GetStableHashCode(asset);
			return new AssetID(stableHashCode, stableHashCode, stableHashCode, stableHashCode);
		}

		public GameObject ClonePrefab(GameObject asset, string newName, Transform parent)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(asset, parent);
			((Object)val).name = newName;
			AddAsset((Object)(object)val, (Object)(object)asset);
			return val;
		}

		public AssetID GetAssetID(Type type, string name)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!IsReady())
			{
				throw new InvalidOperationException("The vanilla asset system is not initialized yet");
			}
			if (MapNameToAssetID.TryGetValue(type, out var value) && value.TryGetValue(name, out var value2))
			{
				return value2;
			}
			if (MapNameToAssetID.TryGetValue(typeof(Object), out value) && value.TryGetValue(name, out value2))
			{
				return value2;
			}
			return default(AssetID);
		}

		public AssetID GetAssetID<T>(string name) where T : Object
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return GetAssetID(typeof(T), name);
		}

		public SoftReference<Object> GetSoftReference(Type type, string name)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			AssetID assetID = GetAssetID(type, name);
			if (!((AssetID)(ref assetID)).IsValid)
			{
				return default(SoftReference<Object>);
			}
			return new SoftReference<Object>(assetID);
		}

		public SoftReference<T> GetSoftReference<T>(string name) where T : Object
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			AssetID assetID = GetAssetID<T>(name);
			if (!((AssetID)(ref assetID)).IsValid)
			{
				return default(SoftReference<T>);
			}
			return new SoftReference<T>(assetID);
		}

		private static Dictionary<Type, Dictionary<string, AssetID>> CreateNameToAssetID()
		{
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			if (!Instance.IsReady())
			{
				throw new InvalidOperationException("The vanilla asset system is not initialized yet");
			}
			Dictionary<Type, Dictionary<string, AssetID>> dictionary = new Dictionary<Type, Dictionary<string, AssetID>>();
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
			foreach (KeyValuePair<string, AssetID> item in Runtime.GetAllAssetPathsInBundleMappedToAssetID().ToList())
			{
				string text = item.Key.Split(new char[1] { '/' }).Last();
				string text2 = text.Split(new char[1] { '.' }).Last();
				string key = text.RemoveSuffix("." + text2);
				if (!(item.Key == "Assets/UI/prefabs/radials/elements/Hammer.prefab") && !(item.Key == "Assets/UI/prefabs/Radial/elements/Hammer.prefab"))
				{
					Type type = Instance.TypeFromExtension(text2);
					if (type == null && text2 == "asset" && text.StartsWith("Recipe_"))
					{
						type = typeof(Recipe);
					}
					if (type == null)
					{
						type = typeof(Object);
					}
					if (!dictionary.ContainsKey(type))
					{
						dictionary.Add(type, new Dictionary<string, AssetID>());
					}
					if (!dictionary[type].ContainsKey(key) || !SkipAmbiguousPath(dictionary2[key], item.Key, text2))
					{
						dictionary[type][key] = item.Value;
						dictionary2[key] = item.Key;
					}
				}
			}
			return dictionary;
		}

		private static bool SkipAmbiguousPath(string oldPath, string newPath, string extension)
		{
			if (extension == "prefab")
			{
				if (oldPath.StartsWith("Assets/world/Locations"))
				{
					return false;
				}
				if (newPath.StartsWith("Assets/world/Locations"))
				{
					return true;
				}
				Logger.LogWarning("Ambiguous asset name for path. old: " + oldPath + ", new: " + newPath + ", using old path");
			}
			return true;
		}

		private Type TypeFromExtension(string extension)
		{
			switch (extension.ToLower())
			{
			case "prefab":
				return typeof(GameObject);
			case "mat":
				return typeof(Material);
			case "obj":
			case "fbx":
				return typeof(Mesh);
			case "png":
			case "jpg":
			case "tga":
			case "tif":
				return typeof(Texture2D);
			case "wav":
			case "mp3":
				return typeof(AudioClip);
			case "controller":
				return typeof(RuntimeAnimatorController);
			case "physicmaterial":
			case "physicsmaterial":
				return typeof(PhysicsMaterial);
			case "shader":
				return typeof(Shader);
			case "anim":
				return typeof(AnimationClip);
			case "mixer":
				return typeof(AudioMixer);
			case "txt":
				return typeof(TextAsset);
			case "ttf":
			case "otf":
				return typeof(TMP_FontAsset);
			case "rendertexture":
				return typeof(RenderTexture);
			case "lighting":
				return typeof(LightingSettings);
			default:
				return null;
			}
		}
	}
	public class CommandManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(Console), "Awake")]
			[HarmonyPostfix]
			private static void AddCustomCommands(Console __instance)
			{
				Instance.AddCustomCommands(__instance);
			}

			[HarmonyPatch(typeof(ConsoleCommand), "GetTabOptions")]
			[HarmonyPostfix]
			private static void ConsoleCommand_GetTabOptions(ConsoleCommand __instance, ref List<string> __result)
			{
				Instance.ConsoleCommand_GetTabOptions(__instance, ref __result);
			}
		}

		private static CommandManager _instance;

		internal static Action<string, List<string>> OnGetTabOptions;

		private List<ConsoleCommand> _customCommands = new List<ConsoleCommand>();

		public static CommandManager Instance => _instance ?? (_instance = new CommandManager());

		public ReadOnlyCollection<ConsoleCommand> CustomCommands => _customCommands.AsReadOnly();

		private CommandManager()
		{
		}

		static CommandManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("CommandManager");
			Main.Harmony.PatchAll(typeof(Patches));
		}

		public void AddConsoleCommand(ConsoleCommand cmd)
		{
			if (_customCommands.Exists((ConsoleCommand c) => c.Name == cmd.Name))
			{
				Logger.LogWarning(cmd.SourceMod, "Cannot have two console commands with same name: " + cmd.Name);
			}
			else if (cmd.Name.Contains(" "))
			{
				Logger.LogWarning(cmd.SourceMod, "Cannot have command containing space: '" + cmd.Name + "'");
			}
			else
			{
				_customCommands.Add(cmd);
			}
		}

		private void AddCustomCommands(Console self)
		{
			if (!_customCommands.Any())
			{
				return;
			}
			Logger.LogInfo($"Adding {_customCommands.Count} commands to the Console");
			foreach (ConsoleCommand customCommand in _customCommands)
			{
				if (((Terminal)self).m_commandList.Contains(customCommand.Name))
				{
					Logger.LogWarning(customCommand.SourceMod, "Cannot override existing command: " + customCommand.Name);
				}
				else
				{
					CreateVanillaCommand(customCommand);
				}
			}
			((Terminal)self).updateCommandList();
		}

		private ConsoleCommand CreateVanillaCommand(ConsoleCommand command)
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			ConstructorInfo constructorInfo = AccessTools.Constructor(typeof(ConsoleCommand), new Type[12]
			{
				typeof(string),
				typeof(string),
				typeof(ConsoleEvent),
				typeof(bool),
				typeof(bool),
				typeof(bool),
				typeof(bool),
				typeof(bool),
				typeof(ConsoleOptionsFetcher),
				typeof(bool),
				typeof(bool),
				typeof(bool)
			}, false);
			if (constructorInfo != null)
			{
				object[] obj = new object[12]
				{
					command.Name,
					command.Help,
					(object)(ConsoleEvent)delegate(ConsoleEventArgs args)
					{
						command.Run(args.Args.Skip(1).ToArray(), args.Context);
					},
					command.IsCheat,
					command.IsNetwork,
					command.OnlyServer,
					command.IsSecret,
					false,
					null,
					null,
					null,
					null
				};
				ConsoleCommand consoleCommand = command;
				obj[8] = (object)new ConsoleOptionsFetcher(consoleCommand.CommandOptionList);
				obj[9] = false;
				obj[10] = false;
				obj[11] = false;
				return (ConsoleCommand)constructorInfo.Invoke(obj);
			}
			Logger.LogError("No suitable constructor for Terminal.ConsoleCommand found");
			return null;
		}

		private void ConsoleCommand_GetTabOptions(ConsoleCommand self, ref List<string> result)
		{
			if (self.m_tabOptions == null && self.m_tabOptionsFetcher != null)
			{
				OnGetTabOptions?.SafeInvoke(self.Command, result);
			}
		}
	}
	public class CreatureManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
			[HarmonyPrefix]
			private static void InvokeOnVanillaCreaturesAvailable()
			{
				Instance.InvokeOnVanillaCreaturesAvailable();
			}

			[HarmonyPatch(typeof(ZNetScene), "Awake")]
			[HarmonyPostfix]
			private static void FixReferences(ZNetScene __instance)
			{
				Instance.FixReferences(__instance);
			}

			[HarmonyPatch(typeof(SpawnSystem), "Awake")]
			[HarmonyPrefix]
			private static void AddSpawnListToSpawnSystem(SpawnSystem __instance)
			{
				Instance.AddSpawnListToSpawnSystem(__instance);
			}

			[HarmonyPatch(typeof(LevelEffects), "SetupLevelVisualization")]
			[HarmonyPostfix]
			private static void EnableCumulativeLevelEffects(LevelEffects __instance, int level)
			{
				Instance.EnableCumulativeLevelEffects(__instance, level);
			}
		}

		private static CreatureManager _instance;

		public static int CharacterLayer;

		internal readonly List<CustomCreature> Creatures = new List<CustomCreature>();

		internal GameObject SpawnListContainer;

		internal SpawnSystemList SpawnList;

		public static CreatureManager Instance => _instance ?? (_instance = new CreatureManager());

		public static event Action OnVanillaCreaturesAvailable;

		public static event Action OnCreaturesRegistered;

		private CreatureManager()
		{
		}

		static CreatureManager()
		{
			CharacterLayer = LayerMask.NameToLayer("character");
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Main.LogInit("CreatureManager");
			SpawnListContainer = new GameObject("Creatures");
			SpawnListContainer.transform.parent = Main.RootObject.transform;
			SpawnListContainer.SetActive(false);
			SpawnList = SpawnListContainer.AddComponent<SpawnSystemList>();
			Main.Harmony.PatchAll(typeof(Patches));
		}

		public bool AddCreature(CustomCreature customCreature)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			if (!customCreature.IsValid())
			{
				Logger.LogWarning(customCreature.SourceMod, $"Custom creature '{customCreature}' is not valid");
				return false;
			}
			if (Creatures.Contains(customCreature))
			{
				Logger.LogWarning(customCreature.SourceMod, $"Custom creature '{customCreature}' already added");
				return false;
			}
			if (!PrefabManager.Instance.AddPrefab(customCreature.Prefab, customCreature.SourceMod))
			{
				return false;
			}
			if (customCreature.Prefab.layer != CharacterLayer)
			{
				customCreature.Prefab.layer = CharacterLayer;
				foreach (Transform item in customCreature.Prefab.transform)
				{
					Transform val = item;
					((Component)val).gameObject.layer = CharacterLayer;
				}
			}
			customCreature.Prefab.transform.SetParent(SpawnListContainer.transform, false);
			Creatures.Add(customCreature);
			SpawnList.m_spawners.AddRange(customCreature.Spawns);
			return true;
		}

		public CustomCreature GetCreature(string creatureName)
		{
			return Creatures.FirstOrDefault((CustomCreature x) => ((Object)x.Prefab).name.Equals(creatureName));
		}

		public GameObject GetCreaturePrefab(string creatureName)
		{
			CustomCreature creature = GetCreature(creatureName);
			if (creature != null)
			{
				return creature.Prefab;
			}
			Character prefab = PrefabManager.Cache.GetPrefab<Character>(creatureName);
			if ((Object)(object)prefab != (Object)null)
			{
				return ((Component)prefab).gameObject;
			}
			return null;
		}

		public void RemoveCreature(string creatureName)
		{
			CustomCreature creature = GetCreature(creatureName);
			if (creature == null)
			{
				Logger.LogWarning("Could not remove Creature " + creatureName + ": Not found");
			}
			else
			{
				RemoveCreature(creature);
			}
		}

		public void RemoveCreature(CustomCreature creature)
		{
			Creatures.Remove(creature);
			if (Object.op_Implicit((Object)(object)creature.Prefab))
			{
				PrefabManager.Instance.RemovePrefab(((Object)creature.Prefab).name);
			}
		}

		private void InvokeOnVanillaCreaturesAvailable()
		{
			CreatureManager.OnVanillaCreaturesAvailable?.SafeInvoke();
		}

		private void FixReferences(ZNetScene self)
		{
			if (Creatures.Any())
			{
				Logger.LogInfo($"Adding {Creatures.Count} custom creatures");
				List<CustomCreature> list = new List<CustomCreature>();
				foreach (CustomCreature creature in Creatures)
				{
					try
					{
						creature.Prefab.GetComponent<CapsuleCollider>()?.FixReferences();
						if (creature.FixReference | creature.FixConfig)
						{
							creature.Prefab.FixReferences(creature.FixReference);
							creature.FixReference = false;
							creature.FixConfig = false;
						}
						Logger.LogDebug($"Added creature {creature} | Spawns: {creature.Spawns.Count}");
					}
					catch (Exception arg)
					{
						Logger.LogWarning(creature?.SourceMod, $"Error caught while adding creature {creature}: {arg}");
						list.Add(creature);
					}
				}
				foreach (CustomCreature item in list)
				{
					if (Object.op_Implicit((Object)(object)item.Prefab))
					{
						PrefabManager.Instance.DestroyPrefab(((Object)item.Prefab).name);
					}
					RemoveCreature(item);
				}
			}
			InvokeOnCreaturesRegistered();
		}

		private void InvokeOnCreaturesRegistered()
		{
			CreatureManager.OnCreaturesRegistered?.SafeInvoke();
		}

		private void AddSpawnListToSpawnSystem(SpawnSystem self)
		{
			if (!self.m_spawnLists.Contains(SpawnList))
			{
				self.m_spawnLists.Add(SpawnList);
			}
		}

		private void EnableCumulativeLevelEffects(LevelEffects self, int level)
		{
			if (level <= 2 || !Creatures.Any((CustomCreature x) => ((Object)x.Prefab).name == self.m_character.m_nview.GetPrefabName() && x.UseCumulativeLevelEffects))
			{
				return;
			}
			for (int num = level - 2; num >= 0; num--)
			{
				if (num < self.m_levelSetups.Count)
				{
					LevelSetup val = self.m_levelSetups[num];
					if (Object.op_Implicit((Object)(object)val.m_enableObject))
					{
						Logger.LogDebug($"Enabling {level - 1} star equipment: '{((Object)val.m_enableObject).name}'");
						val.m_enableObject.SetActive(true);
					}
				}
			}
		}
	}
	public class DungeonManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(ZoneSystem), "SetupLocations")]
			[HarmonyPrefix]
			private static void OnBeforeZoneSystemSetupLocations()
			{
				Instance.OnZoneSystemSetupLocations();
			}

			[HarmonyPatch(typeof(DungeonDB), "Start")]
			[HarmonyPostfix]
			private static void OnDungeonDBStarted()
			{
				Instance.OnDungeonDBStarted();
			}

			[HarmonyPatch(typeof(DungeonDB), "GetRoom")]
			[HarmonyPrefix]
			private static bool OnDungeonDBGetRoom(int hash, ref RoomData __result)
			{
				RoomData val = Instance.OnDungeonDBGetRoom(hash);
				if (val != null)
				{
					__result = val;
					return false;
				}
				return true;
			}

			[HarmonyPatch(typeof(DungeonGenerator), "SetupAvailableRooms")]
			[HarmonyPostfix]
			private static void OnDungeonGeneratorSetupAvailableRooms(DungeonGenerator __instance)
			{
				Instance.OnDungeonGeneratorSetupAvailableRooms(__instance);
			}
		}

		private static DungeonManager _instance;

		internal readonly Dictionary<string, CustomRoom> Rooms = new Dictionary<string, CustomRoom>();

		private readonly Dictionary<int, string> hashToName = new Dictionary<int, string>();

		private readonly List<string> themeList = new List<string>();

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

		internal GameObject DungeonRoomContainer;

		public static DungeonManager Instance => _instance ?? (_instance = new DungeonManager());

		public static event Action OnVanillaRoomsAvailable;

		public static event Action OnRoomsRegistered;

		private DungeonManager()
		{
		}

		static DungeonManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Main.LogInit("DungeonManager");
			DungeonRoomContainer = new GameObject("DungeonRooms");
			DungeonRoomContainer.transform.parent = Main.RootObject.transform;
			DungeonRoomContainer.SetActive(false);
			Main.Harmony.PatchAll(typeof(Patches));
		}

		public bool AddCustomRoom(CustomRoom customRoom)
		{
			if (customRoom == null)
			{
				throw new ArgumentException("Cannot be null", "customRoom");
			}
			if (string.IsNullOrEmpty(customRoom.ThemeName))
			{
				throw new ArgumentException("ThemeName of this room must have a value.", "customRoom");
			}
			if (!CustomRoom.IsVanillaTheme(customRoom.ThemeName) && !themeList.Contains(customRoom.ThemeName))
			{
				throw new ArgumentException("ThemeName of this room (" + customRoom.ThemeName + ") match a vanilla Room.Theme value or must be registered.", "customRoom");
			}
			if (Rooms.ContainsKey(customRoom.Name))
			{
				Logger.LogWarning(customRoom.SourceMod, "Room " + customRoom.Name + " already exists");
				return false;
			}
			if (!customRoom.SoftReference)
			{
				customRoom.Prefab.transform.SetParent(DungeonRoomContainer.transform);
				customRoom.Prefab.SetActive(true);
			}
			Rooms.Add(customRoom.Name, customRoom);
			return true;
		}

		public CustomRoom GetRoom(string name)
		{
			if (!Rooms.TryGetValue(name, out var value))
			{
				return null;
			}
			return value;
		}

		public bool RemoveRoom(string name)
		{
			return Rooms.Remove(name);
		}

		public bool RegisterDungeonTheme(GameObject prefab, string themeName)
		{
			Logger.LogDebug("RegisterDungeonTheme called with prefab " + ((Object)prefab).name + " and themeName " + themeName + ".");
			if ((Object)(object)prefab == (Object)null)
			{
				throw new ArgumentException("Cannot be null", "prefab");
			}
			if (string.IsNullOrEmpty(themeName))
			{
				throw new ArgumentException("Cannot be null or empty", "themeName");
			}
			DungeonGenerator componentInChildren = prefab.GetComponentInChildren<DungeonGenerator>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Logger.LogError("Cannot find DungeonGenerator component in prefab " + ((Object)prefab).name + ".");
				throw new ArgumentException("Prefab must contain a DungeonGenerator component", "prefab");
			}
			DungeonGeneratorTheme dungeonGeneratorTheme = default(DungeonGeneratorTheme);
			if (((Component)componentInChildren).gameObject.TryGetComponent<DungeonGeneratorTheme>(ref dungeonGeneratorTheme))
			{
				if (!string.IsNullOrEmpty(dungeonGeneratorTheme.m_themeName) && dungeonGeneratorTheme.m_themeName != themeName)
				{
					Logger.LogWarning("Overwriting existing theme name " + dungeonGeneratorTheme.m_themeName + " with " + themeName + ".");
				}
			}
			else
			{
				dungeonGeneratorTheme = ((Component)componentInChildren).gameObject.AddComponent<DungeonGeneratorTheme>();
			}
			dungeonGeneratorTheme.m_themeName = themeName;
			themeList.Add(themeName);
			return true;
		}

		public void RegisterEnvironment(AssetBundle assetBundle, string prefabName)
		{
			if ((Object)(object)assetBundle == (Object)null)
			{
				throw new ArgumentException("Cannot be null", "assetBundle");
			}
			if (string.IsNullOrEmpty(prefabName))
			{
				throw new ArgumentException("Cannot be null or empty", "prefabName");
			}
			GameObject value = assetBundle.LoadAsset<GameObject>(prefabName);
			loadedEnvironments.Add(prefabName, value);
		}

		private void GenerateHashes()
		{
			hashToName.Clear();
			foreach (CustomRoom value in Rooms.Values)
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(value.Name);
				if (hashToName.ContainsKey(stableHashCode))
				{
					Logger.LogWarning($"Room {value.Name} is already registered with hash {stableHashCode}");
				}
				else
				{
					hashToName.Add(stableHashCode, value.Name);
				}
			}
		}

		private void OnZoneSystemSetupLocations()
		{
			if (loadedEnvironments.Count <= 0)
			{
				return;
			}
			foreach (KeyValuePair<string, GameObject> loadedEnvironment in loadedEnvironments)
			{
				Logger.LogDebug("Registering environment " + loadedEnvironment.Key + ".");
				GameObject value = loadedEnvironment.Value;
				value.FixReferences(recursive: true);
				Object.Instantiate<GameObject>(value);
			}
		}

		private void OnDungeonDBStarted()
		{
			InvokeOnVanillaRoomsAvailable();
			if (Rooms.Count > 0)
			{
				hashToName.Clear();
				List<string> list = new List<string>();
				Logger.LogInfo($"Registering {Rooms.Count} custom rooms");
				foreach (CustomRoom value in Rooms.Values)
				{
					try
					{
						Logger.LogDebug("Adding custom room " + value.Name + " with " + value.ThemeName + " theme");
						if (value.FixReference && !value.SoftReference)
						{
							value.Prefab.FixReferences(recursive: true);
							value.FixReference = false;
						}
						if (CustomRoom.IsVanillaTheme(value.ThemeName))
						{
							RegisterRoomInDungeonDB(value);
						}
					}
					catch (Exception arg)
					{
						Logger.LogWarning(value.SourceMod, $"Exception caught while adding Room: {arg}");
						list.Add(value.Name);
					}
				}
				foreach (string item in list)
				{
					Rooms.Remove(item);
				}
				DungeonDB.instance.GenerateHashList();
				GenerateHashes();
			}
			InvokeOnRoomsRegistered();
		}

		private void OnDungeonGeneratorSetupAvailableRooms(DungeonGenerator self)
		{
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			DungeonGeneratorTheme proxy = ((Component)self).gameObject.GetComponent<DungeonGeneratorTheme>();
			if (DungeonGenerator.m_availableRooms == null)
			{
				return;
			}
			if ((Object)(object)proxy != (Object)null)
			{
				Logger.LogDebug($"Found DungeonGeneratorTheme component in prefab with name {((Component)self).gameObject}");
				Logger.LogDebug("This dungeon generator has a custom theme = " + proxy.m_themeName + ", adding available rooms");
				IEnumerable<CustomRoom> enumerable = from r in Rooms.Values
					where r.RoomData.m_enabled
					where r.ThemeName == proxy.m_themeName
					select r;
				foreach (CustomRoom item in enumerable)
				{
					Logger.LogDebug("Adding Room with name " + item.Name + " and theme " + item.ThemeName);
					DungeonGenerator.m_availableRooms.Add(item.RoomData);
				}
			}
			else if ((int)self.m_themes != 0)
			{
				Logger.LogDebug($"No DungeonGeneratorTheme component in prefab with name {((Component)self).gameObject}");
				Logger.LogDebug($"Adding additional rooms of type {self.m_themes} to available rooms");
				IEnumerable<CustomRoom> enumerable2 = Rooms.Values.Where((CustomRoom r) => r.RoomData.m_enabled).Where(delegate(CustomRoom r)
				{
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Unknown result type (might be due to invalid IL or missing references)
					if (!Enum.TryParse<Theme>(r.ThemeName, ignoreCase: false, out Theme result))
					{
						return false;
					}
					return (int)result != 0 && ((Enum)self.m_themes).HasFlag((Enum)(object)result);
				});
				foreach (CustomRoom item2 in enumerable2)
				{
					Logger.LogDebug("Adding Room with name " + item2.Name + " and theme " + item2.ThemeName);
					DungeonGenerator.m_availableRooms.Add(item2.RoomData);
				}
			}
			else
			{
				Logger.LogWarning("DungeonManager's SetupAvailableRooms was invoked without a valid DungeonGeneratorTheme or DungeonGenerator.m_themes value. Something may be wrong with " + ((Object)self).name + "'s generator.");
			}
			if (DungeonGenerator.m_availableRooms.Count <= 0)
			{
				Logger.LogDebug("DungeonManager's SetupAvailableRooms yielded zero rooms.");
			}
		}

		private void InvokeOnVanillaRoomsAvailable()
		{
			DungeonManager.OnVanillaRoomsAvailable?.SafeInvoke();
		}

		private void InvokeOnRoomsRegistered()
		{
			DungeonManager.OnRoomsRegistered?.SafeInvoke();
		}

		private void RegisterRoomInDungeonDB(CustomRoom room)
		{
			DungeonDB.instance.m_rooms.Add(room.RoomData);
		}

		private RoomData OnDungeonDBGetRoom(int hash)
		{
			if (hashToName.TryGetValue(hash, out var value) && Rooms.TryGetValue(value, out var value2))
			{
				return value2.RoomData;
			}
			return null;
		}
	}
	public class GUIManager : IManager
	{
		private static class Patches
		{
			[HarmonyPostfix]
			[HarmonyPatch(typeof(PlayerController), "TakeInput")]
			[HarmonyPatch(typeof(Player), "TakeInput")]
			private static void TakeInputPatch(ref bool __result)
			{
				TakeInput(ref __result);
			}

			[HarmonyPatch(typeof(TextInput), "IsVisible")]
			[HarmonyPostfix]
			private static void TextInputPatch(ref bool __result)
			{
				TextInput_IsVisible(ref __result);
			}

			[HarmonyPatch(typeof(InventoryGui), "Update")]
			[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]
			[HarmonyTranspiler]
			[HarmonyWrapSafe]
			private static IEnumerable<CodeInstruction> BlockUsePatch(IEnumerable<CodeInstruction> instructions)
			{
				return BlockUseTranspiler(instructions);
			}

			[HarmonyPatch(typeof(FejdStartup), "SetupGui")]
			[HarmonyPatch(typeof(Game), "Start")]
			[HarmonyPostfix]
			private static void CreateCustomGUI()
			{
				if (!Instance.TryCreateGUI())
				{
					Logger.LogError("Could not create custom GUI");
				}
			}
		}

		private static GUIManager _instance;

		private bool hasInitializedAssets;

		public const int UILayer = 5;

		public Color ValheimBeige = new Color(0.8529f, 0.725f, 0.5331f, 1f);

		public Color ValheimOrange = new Color(1f, 0.631f, 0.235f, 1f);

		public Color ValheimYellow = new Color(1f, 0.889f, 0f, 1f);

		public ColorBlock ValheimScrollbarHandleColorBlock;

		public ColorBlock ValheimToggleColorBlock;

		public ColorBlock ValheimButtonColorBlock;

		public Resources ValheimControlResources;

		private SpriteAtlas UIAtlas;

		private SpriteAtlas IconAtlas;

		private bool GUIInStart;

		internal static bool InputBlocked;

		private static int InputBlockRequests;

		public static GUIManager Instance => _instance ?? (_instance = new GUIManager());

		[Obsolete("Use CustomGUIFront or CustomGUIBack")]
		public static GameObject PixelFix { get; private set; }

		public static GameObject CustomGUIFront { get; private set; }

		public static GameObject CustomGUIBack { get; private set; }

		public Font AveriaSerif { get; private set; }

		public Font AveriaSerifBold { get; private set; }

		public Font Norse { get; private set; }

		public Font NorseBold { get; private set; }

		public TMP_FontAsset TMP_AveriaSansLibre { get; private set; }

		public TMP_FontAsset TMP_Norse { get; private set; }

		[Obsolete("Use OnCustomGUIAvailable")]
		public static event Action OnPixelFixCreated;

		public static event Action OnCustomGUIAvailable;

		private GUIManager()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = new Color(0.926f, 0.645f, 0.34f, 1f);
			((ColorBlock)(ref val)).highlightedColor = new Color(1f, 0.786f, 0.088f, 1f);
			((ColorBlock)(ref val)).pressedColor = new Color(0.838f, 0.647f, 0.03f, 1f);
			((ColorBlock)(ref val)).selectedColor = new Color(1f, 0.786f, 0.088f, 1f);
			((ColorBlock)(ref val)).disabledColor = new Color(0.784f, 0.784f, 0.784f, 0.502f);
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			ValheimScrollbarHandleColorBlock = val;
			val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = new Color(0.61f, 0.61f, 0.61f, 1f);
			((ColorBlock)(ref val)).highlightedColor = new Color(1f, 1f, 1f, 1f);
			((ColorBlock)(ref val)).pressedColor = new Color(0.784f, 0.784f, 0.784f, 1f);
			((ColorBlock)(ref val)).selectedColor = new Color(1f, 1f, 1f, 1f);
			((ColorBlock)(ref val)).disabledColor = new Color(0.784f, 0.784f, 0.784f, 0.502f);
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			ValheimToggleColorBlock = val;
			val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = new Color(0.824f, 0.824f, 0.824f, 1f);
			((ColorBlock)(ref val)).highlightedColor = new Color(1.3f, 1.3f, 1.3f, 1f);
			((ColorBlock)(ref val)).pressedColor = new Color(0.537f, 0.556f, 0.556f, 1f);
			((ColorBlock)(ref val)).selectedColor = new Color(0.824f, 0.824f, 0.824f, 1f);
			((ColorBlock)(ref val)).disabledColor = new Color(0.566f, 0.566f, 0.566f, 0.502f);
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			ValheimButtonColorBlock = val;
			base..ctor();
		}

		static GUIManager()
		{
			((IManager)Instance).Init();
		}

		public static bool IsHeadless()
		{
			return GUIUtils.IsHeadless;
		}

		public static void BlockInput(bool state)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (IsHeadless())
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name == "main")
			{
				if (state)
				{
					InputBlockRequests++;
				}
				else
				{
					InputBlockRequests = Math.Max(--InputBlockRequests, 0);
				}
				if (!InputBlocked && InputBlockRequests > 0)
				{
					EnableInputBlock();
				}
				if (InputBlocked && InputBlockRequests == 0)
				{
					ResetInputBlock();
				}
			}
		}

		private static bool IsInputBlocked()
		{
			return InputBlocked;
		}

		private static void EnableInputBlock()
		{
			InputBlocked = true;
			if (Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				GameCamera.instance.m_mouseCapture = false;
				GameCamera.instance.UpdateMouseCapture();
			}
		}

		private static void ResetInputBlock()
		{
			InputBlocked = false;
			InputBlockRequests = 0;
			if (Object.op_Implicit((Object)(object)GameCamera.instance))
			{
				GameCamera.instance.m_mouseCapture = true;
				GameCamera.instance.UpdateMouseCapture();
			}
		}

		private static void TakeInput(ref bool __result)
		{
			if (InputBlocked)
			{
				__result = false;
			}
		}

		private static void TextInput_IsVisible(ref bool __result)
		{
			if (InputBlocked)
			{
				__result = true;
			}
		}

		void IManager.Init()
		{
			Main.LogInit("GUIManager");
			if (!IsHeadless())
			{
				Instance.TryCreateGUI();
				Main.Harmony.PatchAll(typeof(Patches));
				InitializeAssets();
				SceneManager.sceneLoaded += delegate
				{
					InitializeAssets();
				};
				SceneManager.sceneLoaded += delegate
				{
					Instance.TryCreateGUI();
				};
			}
		}

		private static IEnumerable<CodeInstruction> BlockUseTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			Label? jumpLabel = null;
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.Calls(i, AccessTools.Method(typeof(Menu), "IsVisible", (Type[])null, (Type[])null))), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.Branches(i, ref jumpLabel)), (string)null)
			}).Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(GUIManager), "IsInputBlocked", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Brtrue, (object)jumpLabel)
			})
				.InstructionEnumeration();
		}

		internal void InitializeAssets()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			if (hasInitializedAssets)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (!(((Scene)(ref activeScene)).name == "start") && !(((Scene)(ref activeScene)).name == "main"))
			{
				return;
			}
			try
			{
				UIAtlas = PrefabManager.Cache.GetPrefab<SpriteAtlas>("UIAtlas");
				IconAtlas = PrefabManager.Cache.GetPrefab<SpriteAtlas>("IconAtlas");
				AssertMissingAsset((Object)(object)UIAtlas, "UIAtlas", "SpriteAtlas");
				AssertMissingAsset((Object)(object)IconAtlas, "IconAtlas", "SpriteAtlas");
				AveriaSerif = PrefabManager.Cache.GetPrefab<Font>("AveriaSerifLibre-Regular");
				AveriaSerifBold = PrefabManager.Cache.GetPrefab<Font>("AveriaSerifLibre-Bold");
				Norse = PrefabManager.Cache.GetPrefab<Font>("Norse");
				NorseBold = PrefabManager.Cache.GetPrefab<Font>("Norsebold");
				TMP_AveriaSansLibre = PrefabManager.Cache.GetPrefab<TMP_FontAsset>("Valheim-AveriaSansLibre");
				TMP_Norse = PrefabManager.Cache.GetPrefab<TMP_FontAsset>("Valheim-Norse");
				AssertMissingAsset((Object)(object)AveriaSerif, "AveriaSerif", "Font");
				AssertMissingAsset((Object)(object)AveriaSerifBold, "AveriaSerifBold", "Font");
				AssertMissingAsset((Object)(object)Norse, "Norse", "Font");
				AssertMissingAsset((Object)(object)NorseBold, "NorseBold", "Font");
				AssertMissingAsset((Object)(object)TMP_AveriaSansLibre, "TMP_AveriaSansLibre", "TMP_FontAsset");
				AssertMissingAsset((Object)(object)TMP_Norse, "TMP_Norse", "TMP_FontAsset");
				AssetBundle val = AssetUtils.LoadAssetBundleFromResources("jotunn", typeof(Main).Assembly);
				GameObject val2 = val.LoadAsset<GameObject>("UIMaskStub");
				ValheimControlResources.standard = GetSprite("button");
				ValheimControlResources.background = GetSprite("text_field");
				ValheimControlResources.inputField = GetSprite("text_field");
				ValheimControlResources.knob = GetSprite("checkbox_marker");
				ValheimControlResources.checkmark = GetSprite("checkbox_marker");
				ValheimControlResources.dropdown = GetSprite("checkbox_marker");
				ValheimControlResources.mask = val2.GetComponent<Image>().sprite;
				val.Unload(false);
				AssetBundle val3 = AssetUtils.LoadAssetBundleFromResources("colorpicker", typeof(Main).Assembly);
				GameObject val4 = val3.LoadAsset<GameObject>("ColorPicker");
				Image component = val4.GetComponent<Image>();
				component.sprite = GetSprite("woodpanel_settings");
				component.type = (Type)1;
				component.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
				((Graphic)component).material = PrefabManager.Cache.GetPrefab<Material>("litpanel");
				Text[] componentsInChildren = val4.GetComponentsInChildren<Text>(true);
				foreach (Text val5 in componentsInChildren)
				{
					ApplyTextStyle(val5, ValheimOrange, val5.fontSize);
				}
				InputField[] componentsInChildren2 = val4.GetComponentsInChildren<InputField>(true);
				foreach (InputField field in componentsInChildren2)
				{
					ApplyInputFieldStyle(field, 13);
				}
				Button[] componentsInChildren3 = val4.GetComponentsInChildren<Button>(true);
				foreach (Button button in componentsInChildren3)
				{
					ApplyButtonStyle(button, 13);
				}
				PrefabManager.Instance.AddPrefab(val4, ((BaseUnityPlugin)Main.Instance).Info.Metadata);
				GameObject val6 = val3.LoadAsset<GameObject>("GradientPicker");
				Image component2 = val6.GetComponent<Image>();
				component2.sprite = GetSprite("woodpanel_settings");
				component2.type = (Type)1;
				component2.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
				((Graphic)component2).material = PrefabManager.Cache.GetPrefab<Material>("litpanel");
				Text[] componentsInChildren4 = val6.GetComponentsInChildren<Text>(true);
				foreach (Text val7 in componentsInChildren4)
				{
					ApplyTextStyle(val7, ValheimOrange, val7.fontSize);
				}
				InputField[] componentsInChildren5 = val6.GetComponentsInChildren<InputField>(true);
				foreach (InputField field2 in componentsInChildren5)
				{
					ApplyInputFieldStyle(field2, 13);
				}
				Button[] componentsInChildren6 = val6.GetComponentsInChildren<Button>(true);
				foreach (Button val8 in componentsInChildren6)
				{
					if (((Object)val8).name != "ColorButton")
					{
						ApplyButtonStyle(val8, 13);
					}
				}
				PrefabManager.Instance.AddPrefab(val6, ((BaseUnityPlugin)Main.Instance).Info.Metadata);
				val3.Unload(false);
			}
			catch (Exception data)
			{
				Logger.LogError(data);
			}
			finally
			{
				hasInitializedAssets = true;
			}
		}

		private void AssertMissingAsset(Object asset, string name, string type)
		{
			if (!Object.op_Implicit(asset))
			{
				Logger.LogWarning(name + " (" + type + ") not found");
			}
		}

		private bool TryCreateGUI()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			GUIInStart = ((Scene)(ref activeScene)).name == "start";
			ResetInputBlock();
			if (!((Scene)(ref activeScene)).isLoaded)
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)CustomGUIFront) && Object.op_Implicit((Object)(object)CustomGUIBack))
			{
				return true;
			}
			Transform val = FindGUIRoot();
			if (Object.op_Implicit((Object)(object)val))
			{
				CustomGUIFront = CreateCustomGUI("CustomGUIFront", 2000, val);
				CustomGUIFront.transform.SetAsLastSibling();
				CustomGUIBack = CreateCustomGUI("CustomGUIBack", 0, val);
				CustomGUIBack.transform.SetAsFirstSibling();
				PixelFix = CustomGUIFront;
				InvokeOnPixelFixCreated();
				InvokeOnCustomGUIAvailable();
				return true;
			}
			return false;
		}

		private static Transform FindGUIRoot()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			GameObject[] array = rootGameObjects;
			foreach (GameObject val in array)
			{
				string name = ((Object)val).name;
				if (name == "GuiRoot")
				{
					return val.transform.Find("GUI");
				}
				if (name == "_GameMain")
				{
					return val.transform.Find("LoadingGUI");
				}
			}
			return null;
		}

		private GameObject CreateCustomGUI(string name, int sortingOrder, Transform parent)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[5]
			{
				typeof(RectTransform),
				typeof(GuiPixelFix),
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(GraphicRaycaster)
			});
			val.layer = 5;
			val.transform.SetParent(((Component)parent).transform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			component.anchoredPosition = Vector2.zero;
			Canvas component2 = val.GetComponent<Canvas>();
			component2.additionalShaderChannels = (AdditionalCanvasShaderChannels)25;
			component2.renderMode = (RenderMode)0;
			component2.overrideSorting = true;
			component2.sortingOrder = sortingOrder;
			CanvasScaler component3 = val.GetComponent<CanvasScaler>();
			component3.referencePixelsPerUnit = 50f;
			return val;
		}

		[Obsolete]
		private void InvokeOnPixelFixCreated()
		{
			GUIManager.OnPixelFixCreated?.SafeInvoke();
		}

		private void InvokeOnCustomGUIAvailable()
		{
			GUIManager.OnCustomGUIAvailable?.SafeInvoke();
		}

		[Obsolete("Use KeyHintManager.AddKeyHint instead")]
		public bool AddKeyHint(KeyHintConfig hintConfig)
		{
			return KeyHintManager.Instance.AddKeyHint(hintConfig);
		}

		[Obsolete("Use KeyHintManager.RemoveKeyHint instead")]
		public void RemoveKeyHint(KeyHintConfig hintConfig)
		{
			KeyHintManager.Instance.RemoveKeyHint(hintConfig);
		}

		public Sprite GetSprite(string spriteName)
		{
			SpriteAtlas uIAtlas = UIAtlas;
			Sprite val = ((uIAtlas != null) ? uIAtlas.GetSprite(spriteName) : null);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			SpriteAtlas iconAtlas = IconAtlas;
			val = ((iconAtlas != null) ? iconAtlas.GetSprite(spriteName) : null);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			val = PrefabManager.Cache.GetPrefab<Sprite>(spriteName);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Logger.LogWarning("Sprite " + spriteName + " not found.");
			return null;
		}

		public void CreateColorPicker(Vector2 anchorMin, Vector2 anchorMax, Vector2 position, Color original, string message, ColorPicker.ColorEvent onColorChanged, ColorPicker.ColorEvent onColorSelected, bool useAlpha = false)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)CustomGUIFront == (Object)null)
			{
				Logger.LogError("GUIManager CustomGUIFront is null");
				return;
			}
			GameObject prefab = PrefabManager.Instance.GetPrefab("ColorPicker");
			if ((Object)(object)prefab == (Object)null)
			{
				Logger.LogError("ColorPicker is null");
			}
			if ((Object)(object)CustomGUIFront.transform.Find("ColorPicker") == (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(prefab, CustomGUIFront.transform, false);
				((Object)val).name = "ColorPicker";
				val.GetComponent<Image>().pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchoredPosition = position;
				component.anchorMin = anchorMin;
				component.anchorMax = anchorMax;
			}
			CustomGUIFront.transform.Find("ColorPicker").SetAsLastSibling();
			ColorPicker.Create(original, message, onColorChanged, onColorSelected, useAlpha);
		}

		public void CreateGradientPicker(Vector2 anchorMin, Vector2 anchorMax, Vector2 position, Gradient original, string message, GradientPicker.GradientEvent onGradientChanged, GradientPicker.GradientEvent onGradientSelected)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)CustomGUIFront == (Object)null)
			{
				Logger.LogError("GUIManager CustomGUIFront is null");
				return;
			}
			GameObject prefab = PrefabManager.Instance.GetPrefab("GradientPicker");
			if ((Object)(object)prefab == (Object)null)
			{
				Logger.LogError("GradientPicker is null");
			}
			GameObject prefab2 = PrefabManager.Instance.GetPrefab("ColorPicker");
			if ((Object)(object)prefab2 == (Object)null)
			{
				Logger.LogError("ColorPicker is null");
			}
			if ((Object)(object)CustomGUIFront.transform.Find("GradientPicker") == (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(prefab, CustomGUIFront.transform, false);
				((Object)val).name = "GradientPicker";
				val.GetComponent<Image>().pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchoredPosition = position;
				component.anchorMin = anchorMin;
				component.anchorMax = anchorMax;
			}
			CustomGUIFront.transform.Find("GradientPicker").SetAsLastSibling();
			if ((Object)(object)CustomGUIFront.transform.Find("ColorPicker") == (Object)null)
			{
				GameObject val2 = Object.Instantiate<GameObject>(prefab2, CustomGUIFront.transform, false);
				((Object)val2).name = "ColorPicker";
				val2.GetComponent<Image>().pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			}
			CustomGUIFront.transform.Find("ColorPicker").SetAsLastSibling();
			GradientPicker.Create(original, message, onGradientChanged, onGradientSelected);
		}

		public GameObject CreateWoodpanel(Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 position, float width = 0f, float height = 0f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return CreateWoodpanel(parent, anchorMin, anchorMax, position, width, height, draggable: true);
		}

		public GameObject CreateWoodpanel(Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 position, float width = 0f, float height = 0f, bool draggable = true)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = DefaultControls.CreatePanel(ValheimControlResources);
			val.transform.SetParent(parent, false);
			ApplyWoodpanelStyle(val.transform);
			val.GetComponent<Image>().pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchoredPosition = position;
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			if (width > 0f)
			{
				val2.SetSizeWithCurrentAnchors((Axis)0, width);
			}
			if (height > 0f)
			{
				val2.SetSizeWithCurrentAnchors((Axis)1, height);
			}
			if (draggable)
			{
				val.AddComponent<DragWindowCntrl>();
			}
			return val;
		}

		public GameObject CreateScrollView(Transform parent, bool showHorizontalScrollbar, bool showVerticalScrollbar, float handleSize, float handleDistanceToBorder, ColorBlock handleColors, Color slidingAreaBackgroundColor, float width, float height)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Expected O, but got Unknown
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Expected O, but got Unknown
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Expected O, but got Unknown
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0521: Unknown result type (might be due to invalid IL or missing references)
			//IL_0528: Expected O, but got Unknown
			//IL_053d: Unknown result type (might be due to invalid IL or missing references)
			//IL_096e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0974: Expected O, but got Unknown
			//IL_0994: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_0639: Expected O, but got Unknown
			//IL_066f: Unknown result type (might be due to invalid IL or missing references)
			//IL_068a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_070d: Unknown result type (might be due to invalid IL or missing references)
			//IL_072c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0733: Expected O, but got Unknown
			//IL_0744: Unknown result type (might be due to invalid IL or missing references)
			//IL_075f: Unknown result type (might be due to invalid IL or missing references)
			//IL_077a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0795: Unknown result type (might be due to invalid IL or missing references)
			//IL_0802: Unknown result type (might be due to invalid IL or missing references)
			//IL_0809: Expected O, but got Unknown
			//IL_081a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_0853: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Canvas", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasGroup),
				typeof(GraphicRaycaster)
			});
			val.GetComponent<Canvas>().sortingOrder = 0;
			val.GetComponent<RectTransform>().anchorMin = new Vector2(0.5f, 0.5f);
			val.GetComponent<RectTransform>().anchorMax = new Vector2(0.5f, 0.5f);
			val.GetComponent<RectTransform>().pivot = new Vector2(0.5f, 0.5f);
			((Transform)val.GetComponent<RectTransform>()).localPosition = new Vector3(0f, 0f, 0f);
			((Transform)val.GetComponent<RectTransform>()).position = new Vector3(0f, 0f, 0f);
			val.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 0f);
			val.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, width);
			val.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, height);
			val.GetComponent<CanvasGroup>().interactable = true;
			val.GetComponent<CanvasGroup>().ignoreParentGroups = true;
			val.GetComponent<CanvasGroup>().blocksRaycasts = true;
			val.GetComponent<CanvasGroup>().alpha = 1f;
			val.transform.SetParent(parent, false);
			GameObject val2 = GameObjectGUIExtension.SetUpperRight(new GameObject("Scroll View", new Type[3]
			{
				typeof(Image),
				typeof(ScrollRect),
				typeof(Mask)
			}));
			val2.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, width);
			val2.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, height);
			((Graphic)val2.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 1f);
			val2.GetComponent<ScrollRect>().horizontal = showHorizontalScrollbar;
			val2.GetComponent<ScrollRect>().vertical = showVerticalScrollbar;
			val2.GetComponent<ScrollRect>().horizontalScrollbarVisibility = (ScrollbarVisibility)1;
			val2.GetComponent<ScrollRect>().verticalScrollbarVisibility = (ScrollbarVisibility)2;
			val2.GetComponent<ScrollRect>().scrollSensitivity = 35f;
			val2.GetComponent<Mask>().showMaskGraphic = false;
			val2.transform.SetParent(val.transform, false);
			GameObject val3 = new GameObject("Viewport", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val3.GetComponent<RectTransform>().anchorMin = new Vector2(0f, 1f);
			val3.GetComponent<RectTransform>().anchorMax = new Vector2(0f, 1f);
			val3.GetComponent<RectTransform>().pivot = new Vector2(0f, 1f);
			val3.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, width);
			val3.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, height);
			((Graphic)val3.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0f);
			val3.transform.SetParent(val2.transform, false);
			val2.GetComponent<ScrollRect>().viewport = val3.GetComponent<RectTransform>();
			if (showHorizontalScrollbar)
			{
				GameObject val4 = new GameObject("Scrollbar horizontal", new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(Scrollbar)
				});
				val4.transform.SetParent(val2.transform, false);
				val2.GetComponent<ScrollRect>().horizontalScrollbar = val4.GetComponent<Scrollbar>();
				val4.GetComponent<RectTransform>().anchorMin = new Vector2(0.5f, 1f);
				val4.GetComponent<RectTransform>().anchorMax = new Vector2(0.5f, 1f);
				val4.GetComponent<RectTransform>().pivot = new Vector2(0.5f, 1f);
				val4.GetComponent<RectTransform>().anchoredPosition = new Vector2((0f - handleSize) / 2f, 0f - height + handleSize);
				val4.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, width - 2f * handleDistanceToBorder - handleSize);
				val4.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, handleSize);
				((Graphic)val4.GetComponent<Image>()).color = slidingAreaBackgroundColor;
				((Selectable)val4.GetComponent<Scrollbar>()).colors = handleColors;
				GameObject val5 = new GameObject("Sliding Area", new Type[1] { typeof(RectTransform) });
				val5.GetComponent<RectTransform>().anchorMin = new Vector2(0f, 1f);
				val5.GetComponent<RectTransform>().anchorMax = new Vector2(0f, 1f);
				val5.GetComponent<RectTransform>().pivot = new Vector2(0f, 0.5f);
				val5.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 0f);
				val5.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, width - 2f * handleDistanceToBorder - handleSize);
				val5.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, handleSize);
				val5.transform.SetParent(val4.transform, false);
				GameObject val6 = new GameObject("Handle", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val6.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, (0f - handleSize) / 2f);
				val6.transform.SetParent(val5.transform, false);
				val6.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, handleSize / 2f);
				val6.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, handleSize / 2f);
				val6.GetComponent<Image>().sprite = GetSprite("UISprite");
				val6.GetComponent<Image>().type = (Type)1;
				val4.GetComponent<Scrollbar>().size = 0.4f;
				val4.GetComponent<Scrollbar>().handleRect = val6.GetComponent<RectTransform>();
				((Selectable)val4.GetComponent<Scrollbar>()).targetGraphic = (Graphic)(object)val6.GetComponent<Image>();
				val4.GetComponent<Scrollbar>().direction = (Direction)0;
			}
			if (showVerticalScrollbar)
			{
				GameObject val7 = new GameObject("Scrollbar Vertical", new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(Scrollbar)
				});
				val7.transform.SetParent(val2.transform, false);
				val2.GetComponent<ScrollRect>().verticalScrollbar = val7.GetComponent<Scrollbar>();
				val7.GetComponent<RectTransform>().anchorMin = new Vector2(1f, 0.5f);
				val7.GetComponent<RectTransform>().anchorMax = new Vector2(1f, 0.5f);
				val7.GetComponent<RectTransform>().pivot = new Vector2(1f, 0.5f);
				val7.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, (0f - handleSize) / 2f);
				val7.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, handleSize);
				val7.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, height - 2f * handleDistanceToBorder - handleSize);
				((Graphic)val7.GetComponent<Image>()).color = slidingAreaBackgroundColor;
				((Selectable)val7.GetComponent<Scrollbar>()).colors = handleColors;
				GameObject val8 = new GameObject("Sliding Area", new Type[1] { typeof(RectTransform) });
				val8.GetComponent<RectTransform>().anchorMin = new Vector2(0f, 1f);
				val8.GetComponent<RectTransform>().anchorMax = new Vector2(0f, 1f);
				val8.GetComponent<RectTransform>().pivot = new Vector2(0.5f, 1f);
				val8.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 0f);
				val8.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, handleSize);
				val8.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, height - 2f * handleDistanceToBorder - handleSize);
				val8.transform.SetParent(val7.transform, false);
				GameObject val9 = new GameObject("Handle", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val9.GetComponent<RectTransform>().anchorMin = new Vector2(0.5f, 0.5f);
				val9.GetComponent<RectTransform>().anchorMax = new Vector2(0.5f, 0.5f);
				val9.GetComponent<RectTransform>().anchoredPosition = new Vector2(handleSize / 2f, 0f);
				val9.transform.SetParent(val8.transform, false);
				val9.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, handleSize / 2f);
				val9.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, handleSize / 2f);
				val9.GetComponent<Image>().sprite = GetSprite("UISprite");
				val9.GetComponent<Image>().type = (Type)1;
				val7.GetComponent<Scrollbar>().size = 0.4f;
				val7.GetComponent<Scrollbar>().handleRect = val9.GetComponent<RectTransform>();
				((Selectable)val7.GetComponent<Scrollbar>()).targetGraphic = (Graphic)(object)val9.GetComponent<Image>();
				val7.GetComponent<Scrollbar>().size = handleSize;
				val7.GetComponent<Scrollbar>().direction = (Direction)2;
				val7.GetComponent<Scrollbar>().SetValueWithoutNotify(1f);
			}
			GameObject val10 = new GameObject("Content", new Type[5]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(Canvas),
				typeof(GraphicRaycaster),
				typeof(ContentSizeFitter)
			});
			val10.GetComponent<Canvas>().planeDistance = 5.2f;
			val10.GetComponent<RectTransform>().anchorMin = new Vector2(0f, 1f);
			val10.GetComponent<RectTransform>().anchorMax = new Vector2(0f, 1f);
			val10.GetComponent<RectTransform>().pivot = new Vector2(0f, 1f);
			val10.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, width - 2f * handleDistanceToBorder - handleSize);
			val10.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, height - 2f * handleDistanceToBorder - handleSize);
			((LayoutGroup)val10.GetComponent<VerticalLayoutGroup>()).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)val10.GetComponent<VerticalLayoutGroup>()).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val10.GetComponent<VerticalLayoutGroup>()).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val10.GetComponent<VerticalLayoutGroup>()).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val10.GetComponent<VerticalLayoutGroup>()).childControlWidth = showHorizontalScrollbar;
			val10.transform.SetParent(val3.transform, false);
			val10.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			val2.GetComponent<ScrollRect>().content = val10.GetComponent<RectTransform>();
			return val;
		}

		public GameObject CreateText(string text, Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 position, Font font, int fontSize, Color color, bool outline, Color outlineColor, float width, float height, bool addContentSizeFitter)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Text", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = anchorMin;
			component.anchorMax = anchorMax;
			component.anchoredPosition = position;
			if (!addContentSizeFitter)
			{
				component.SetSizeWithCurrentAnchors((Axis)0, width);
				component.SetSizeWithCurrentAnchors((Axis)1, height);
			}
			else
			{
				val.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			}
			Text component2 = val.GetComponent<Text>();
			component2.text = text;
			ApplyTextStyle(component2, font, color, fontSize, outline);
			Outline val2 = default(Outline);
			if (val.TryGetComponent<Outline>(ref val2))
			{
				((Shadow)val2).effectColor = outlineColor;
			}
			val.transform.SetParent(parent, false);
			return val;
		}

		public GameObject CreateButton(string text, Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 position, float width = 0f, float height = 0f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = DefaultControls.CreateButton(ValheimControlResources);
			val.transform.SetParent(parent, false);
			ApplyButtonStyle(val.GetComponent<Button>());
			Text componentInChildren = val.GetComponentInChildren<Text>();
			componentInChildren.text = text;
			Transform transform = val.transform;
			RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			val2.anchoredPosition = position;
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			if (width > 0f)
			{
				val2.SetSizeWithCurrentAnchors((Axis)0, width);
				((Component)componentInChildren).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, width);
			}
			if (height > 0f)
			{
				val2.SetSizeWithCurrentAnchors((Axis)1, height);
				((Component)componentInChildren).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, height);
			}
			return val;
		}

		public GameObject CreateInputField(Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 position, ContentType contentType = (ContentType)0, string placeholderText = null, int fontSize = 16, float width = 0f, float height = 0f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = DefaultControls.CreateInputField(ValheimControlResources);
			val.transform.SetParent(parent, false);
			InputField component = val.GetComponent<InputField>();
			ApplyInputFieldStyle(component, fontSize);
			component.contentType = contentType;
			if (!string.IsNullOrEmpty(placeholderText))
			{
				Graphic placeholder = component.placeholder;
				Text val2 = (Text)(object)((placeholder is Text) ? placeholder : null);
				if (val2 != null)
				{
					val2.text = placeholderText;
				}
			}
			Transform transform = val.transform;
			RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			val3.anchoredPosition = position;
			val3.anchorMin = anchorMin;
			val3.anchorMax = anchorMax;
			if (width > 0f)
			{
				val.SetWidth(width);
				((Component)component.placeholder).gameObject.SetWidth(width - 20f);
				((Component)component.textComponent).gameObject.SetWidth(width - 20f);
			}
			if (height > 0f)
			{
				val.SetHeight(height);
				((Component)component.placeholder).gameObject.SetHeight(height - 10f);
				((Component)component.textComponent).gameObject.SetHeight(height - 10f);
			}
			return val;
		}

		public GameObject CreateToggle(Transform parent, float width, float height)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = DefaultControls.CreateToggle(ValheimControlResources);
			val.transform.SetParent(parent);
			Toggle component = val.GetComponent<Toggle>();
			ApplyToogleStyle(component);
			val.SetSize(width, height);
			((Component)val.transform.Find("Background")).gameObject.SetSize(width, height);
			((Component)val.transform.Find("Background/Checkmark")).gameObject.SetSize(width, height);
			return val;
		}

		public GameObject CreateDropDown(Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 position, int fontSize = 16, float width = 0f, float height = 0f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = DefaultControls.CreateDropdown(ValheimControlResources);
			val.transform.SetParent(parent, false);
			Dropdown component = val.GetComponent<Dropdown>();
			component.ClearOptions();
			ApplyDropdownStyle(component, fontSize);
			Transform transform = val.transform;
			RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			val2.anchoredPosition = position;
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			if (width > 0f)
			{
				float width2 = width - 50f;
				val.SetWidth(width);
				((Component)component.captionText).gameObject.SetMiddleLeft();
				((Component)component.captionText).gameObject.SetWidth(width2);
				((Component)component.captionText).GetComponent<RectTransform>().anchoredPosition = Vector2.op_Implicit(new Vector3(10f, 0f));
				((Component)component.itemText).gameObject.SetWidth(width2);
			}
			if (height > 0f)
			{
				val.SetHeight(height);
				((Component)component.captionText).gameObject.SetMiddleLeft();
				((Component)component.captionText).gameObject.SetHeight(height);
				((Component)component.captionText).GetComponent<RectTransform>().anchoredPosition = Vector2.op_Implicit(new Vector3(10f, 0f));
				((Component)component.itemText).gameObject.SetHeight(height);
			}
			return val;
		}

		public GameObject CreateKeyBindField(string text, Transform parent, float width, float height)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObjectGUIExtension.SetUpperLeft(new GameObject("KeyBinding", new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			})).SetSize(width, height);
			val.GetComponent<LayoutElement>().preferredWidth = width;
			GameObject val2 = CreateText(text, val.transform, new Vector2(0f, 0f), new Vector2(0f, 0f), new Vector2(0f, 0f), AveriaSerifBold, 16, ValheimOrange, outline: true, Color.black, width - 150f, 0f, addContentSizeFitter: false);
			val2.GetComponent<Text>().verticalOverflow = (VerticalWrapMode)1;
			val2.SetUpperLeft().SetToTextHeight();
			val.SetHeight(val2.GetTextHeight());
			val.transform.SetParent(parent, false);
			GameObject val3 = GameObjectGUIExtension.SetUpperRight(new GameObject("Button", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			})).SetSize(140f, val2.GetTextHeight());
			val3.transform.SetParent(val.transform, false);
			((Selectable)val3.GetComponent<Button>()).image = val3.GetComponent<Image>();
			val3.GetComponent<Image>().sprite = GetSprite("text_field");
			GameObject val4 = GameObjectGUIExtension.SetMiddleCenter(new GameObject("Text", new Type[2]
			{
				typeof(RectTransform),
				typeof(Text)
			}));
			Text component = val4.GetComponent<Text>();
			ApplyTextStyle(component, component.fontSize);
			component.text = "";
			GameObject go = val4.SetHeight(val4.GetTextHeight() + height - 2f);
			Rect rect = val3.GetComponent<RectTransform>().rect;
			go.SetWidth(((Rect)(ref rect)).width);
			val4.SetMiddleLeft().GetComponent<Text>().alignment = (TextAnchor)4;
			val3.SetHeight(val4.GetTextHeight() + height);
			val4.transform.SetParent(val3.transform, false);
			return val;
		}

		public void ApplyWoodpanelStyle(Transform woodpanel)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			((Component)woodpanel).GetComponent<RectTransform>().anchorMin = new Vector2(0.5f, 0.5f);
			((Component)woodpanel).GetComponent<RectTransform>().anchorMax = new Vector2(0.5f, 0.5f);
			((Component)woodpanel).GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 0f);
			((Component)woodpanel).GetComponent<Image>().sprite = GetSprite("woodpanel_trophys");
			((Component)woodpanel).GetComponent<Image>().type = (Type)1;
			((Component)woodpanel).GetComponent<Image>().pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			((Graphic)((Component)woodpanel).GetComponent<Image>()).material = PrefabManager.Cache.GetPrefab<Material>("litpanel");
			((Graphic)((Component)woodpanel).GetComponent<Image>()).color = Color.white;
			((Component)woodpanel).gameObject.layer = 5;
		}

		public void ApplyTextStyle(Text text, Font font, Color color, int fontSize = 16, bool createOutline = true)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			text.font = font;
			text.fontSize = fontSize;
			((Graphic)text).color = color;
			if (createOutline)
			{
				Outline orAddComponent = ((Component)text).gameObject.GetOrAddComponent<Outline>();
				((Shadow)orAddComponent).effectColor = Color.black;
			}
		}

		public void ApplyTextStyle(Text text, Color color, int fontSize = 16, bool createOutline = true)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ApplyTextStyle(text, AveriaSerifBold, color, fontSize, createOutline);
		}

		public void ApplyTextStyle(Text text, int fontSize = 16)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ApplyTextStyle(text, AveriaSerifBold, Color.white, fontSize);
		}

		public void ApplyButtonStyle(Button button, int fontSize = 16)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)button).gameObject;
			Image component = gameObject.GetComponent<Image>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.sprite = GetSprite("button");
				component.type = (Type)1;
				component.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
				((Selectable)button).image = component;
			}
			ButtonSfx val = default(ButtonSfx);
			if (!gameObject.TryGetComponent<ButtonSfx>(ref val))
			{
				val = gameObject.AddComponent<ButtonSfx>();
			}
			val.m_sfxPrefab = PrefabManager.Cache.GetPrefab<GameObject>("sfx_gui_button");
			val.m_selectSfxPrefab = PrefabManager.Cache.GetPrefab<GameObject>("sfx_gui_select");
			((Selectable)gameObject.GetComponent<Button>()).colors = ValheimButtonColorBlock;
			Text componentInChildren = gameObject.GetComponentInChildren<Text>(true);
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				ApplyTextStyle(componentInChildren, ValheimOrange, fontSize);
				componentInChildren.alignment = (TextAnchor)4;
			}
		}

		[Obsolete("Only here for backward compat")]
		public void ApplyInputFieldStyle(InputField field)
		{
			ApplyInputFieldStyle(field, 16);
		}

		public void ApplyInputFieldStyle(InputField field, int fontSize = 16)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Graphic targetGraphic = ((Selectable)field).targetGraphic;
			Image val = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			if (val != null)
			{
				((Graphic)val).color = Color.white;
				val.sprite = GetSprite("text_field");
				val.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			}
			Graphic placeholder = field.placeholder;
			Text val2 = (Text)(object)((placeholder is Text) ? placeholder : null);
			if (val2 != null)
			{
				val2.font = AveriaSerifBold;
				((Graphic)val2).color = Color.grey;
				val2.fontSize = fontSize;
			}
			if (Object.op_Implicit((Object)(object)field.textComponent))
			{
				ApplyTextStyle(field.textComponent, fontSize);
			}
		}

		public void ApplyToogleStyle(Toggle toggle)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			toggle.toggleTransition = (ToggleTransition)1;
			((Selectable)toggle).colors = ValheimToggleColorBlock;
			Graphic targetGraphic = ((Selectable)toggle).targetGraphic;
			Image val = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			if (val != null)
			{
				val.sprite = GetSprite("checkbox");
				val.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			}
			Graphic graphic = toggle.graphic;
			Image val2 = (Image)(object)((graphic is Image) ? graphic : null);
			if (val2 != null)
			{
				((Graphic)val2).color = new Color(1f, 0.678f, 0.103f, 1f);
				val2.sprite = GetSprite("checkbox_marker");
				val2.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
				((MaskableGraphic)val2).maskable = true;
			}
		}

		public void ApplyDropdownStyle(Dropdown dropdown, int fontSize = 16)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			((Component)dropdown).gameObject.layer = 5;
			if ((Object)(object)dropdown.template != (Object)null)
			{
				((Component)dropdown.template).gameObject.layer = 5;
			}
			if (Object.op_Implicit((Object)(object)dropdown.captionText))
			{
				ApplyTextStyle(dropdown.captionText, fontSize);
				dropdown.captionText.verticalOverflow = (VerticalWrapMode)1;
			}
			if (Object.op_Implicit((Object)(object)dropdown.itemText))
			{
				ApplyTextStyle(dropdown.itemText, fontSize);
				dropdown.captionText.verticalOverflow = (VerticalWrapMode)1;
			}
			Image val = default(Image);
			if (((Component)dropdown).TryGetComponent<Image>(ref val))
			{
				val.sprite = GetSprite("text_field");
				val.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			}
			GameObject gameObject = ((Component)((Component)dropdown).transform.Find("Arrow")).gameObject;
			gameObject.transform.localRotation = Quaternion.Euler(new Vector3(0f, 0f, 180f));
			Image val2 = default(Image);
			if (gameObject.TryGetComponent<Image>(ref val2))
			{
				gameObject.SetSize(25f, 25f);
				val2.sprite = GetSprite("map_marker");
				((Graphic)val2).color = Color.white;
				val2.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			}
			ScrollRect scrollRect = default(ScrollRect);
			if (Object.op_Implicit((Object)(object)dropdown.template) && ((Component)dropdown.template).TryGetComponent<ScrollRect>(ref scrollRect))
			{
				ApplyScrollRectStyle(scrollRect);
			}
			Image val3 = default(Image);
			if (Object.op_Implicit((Object)(object)dropdown.template) && ((Component)dropdown.template).TryGetComponent<Image>(ref val3))
			{
				val3.sprite = GetSprite("button_small");
				((Graphic)val3).color = Color.white;
				val3.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			}
			GameObject gameObject2 = ((Component)((Transform)dropdown.template).Find("Viewport/Content/Item")).gameObject;
			Toggle val4 = default(Toggle);
			if (Object.op_Implicit((Object)(object)gameObject2) && gameObject2.TryGetComponent<Toggle>(ref val4))
			{
				val4.toggleTransition = (ToggleTransition)0;
				((Selectable)val4).colors = ValheimToggleColorBlock;
				Toggle obj = val4;
				SpriteState spriteState = default(SpriteState);
				((SpriteState)(ref spriteState)).highlightedSprite = GetSprite("button_highlight");
				((Selectable)obj).spriteState = spriteState;
				Graphic targetGraphic = ((Selectable)val4).targetGraphic;
				Image val5 = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
				if (val5 != null)
				{
					((Behaviour)val5).enabled = false;
				}
				Graphic graphic = val4.graphic;
				Image val6 = (Image)(object)((graphic is Image) ? graphic : null);
				if (val6 != null)
				{
					val6.sprite = GetSprite("checkbox_marker");
					((Graphic)val6).color = Color.white;
					val6.type = (Type)0;
					((MaskableGraphic)val6).maskable = true;
					val6.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
					((Shadow)((Component)val6).gameObject.GetOrAddComponent<Outline>()).effectColor = Color.black;
				}
			}
		}

		public void ApplyScrollRectStyle(ScrollRect scrollRect)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			scrollRect.scrollSensitivity = 40f;
			if (Object.op_Implicit((Object)(object)scrollRect.horizontalScrollbar))
			{
				ApplyScrollbarStyle(scrollRect.horizontalScrollbar);
			}
			if (Object.op_Implicit((Object)(object)scrollRect.verticalScrollbar))
			{
				ApplyScrollbarStyle(scrollRect.verticalScrollbar);
			}
			Image val = default(Image);
			if (((Component)scrollRect).TryGetComponent<Image>(ref val))
			{
				((Graphic)val).color = new Color(0f, 0f, 0f, 0.564f);
				val.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			}
		}

		public void ApplyScrollbarStyle(Scrollbar scrollbar)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			((Selectable)scrollbar).transition = (Transition)1;
			((Selectable)scrollbar).colors = ValheimScrollbarHandleColorBlock;
			RectTransform val = (RectTransform)((Component)scrollbar).transform;
			if ((int)scrollbar.direction == 0 || (int)scrollbar.direction == 1)
			{
				val.sizeDelta = new Vector2(val.sizeDelta.x, 10f);
			}
			if ((int)scrollbar.direction == 2 || (int)scrollbar.direction == 3)
			{
				val.sizeDelta = new Vector2(10f, val.sizeDelta.y);
			}
			Graphic targetGraphic = ((Selectable)scrollbar).targetGraphic;
			Image val2 = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			if (val2 != null)
			{
				val2.sprite = GetSprite("UISprite");
				val2.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			}
			Image val3 = default(Image);
			if (((Component)scrollbar).TryGetComponent<Image>(ref val3))
			{
				val3.sprite = GetSprite("Background");
				((Graphic)val3).color = Color.black;
				((Graphic)val3).raycastTarget = true;
				val3.pixelsPerUnitMultiplier = (GUIInStart ? 2f : 1f);
			}
		}

		public void ApplySliderStyle(Slider slider)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			ApplySliderStyle(slider, new Vector2(40f, 10f));
		}

		public void ApplySliderStyle(Slider slider, Vector2 handleSize)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			slider.handleRect.sizeDelta = handleSize;
			Image val = default(Image);
			if (Object.op_Implicit((Object)(object)slider.fillRect) && ((Component)slider.fillRect).TryGetComponent<Image>(ref val))
			{
				val.sprite = GetSprite("UISprite");
				((Graphic)val).color = ValheimOrange;
			}
			if (Object.op_Implicit((Object)(object)slider.handleRect) && Object.op_Implicit((Object)(object)((Component)slider.handleRect).transform.parent))
			{
				RectTransform val2 = (RectTransform)((Component)slider.handleRect).transform.parent;
				val2.offsetMin = new Vector2(5f, val2.offsetMin.y);
				val2.offsetMax = new Vector2(-5f, val2.offsetMax.y);
			}
			if (Object.op_Implicit((Object)(object)slider.handleRect) && Object.op_Implicit((Object)(object)((Component)slider.fillRect).transform.parent))
			{
				RectTransform val3 = (RectTransform)((Component)slider.fillRect).transform.parent;
				val3.offsetMin = new Vector2(5f, val3.offsetMin.y);
				val3.offsetMax = new Vector2(-5f, val3.offsetMax.y);
			}
		}
	}
	public class InputManager : IManager
	{
		public enum GamepadButton
		{
			None,
			DPadUp,
			DPadDown,
			DPadLeft,
			DPadRight,
			ButtonSouth,
			ButtonEast,
			ButtonWest,
			ButtonNorth,
			LeftShoulder,
			RightShoulder,
			LeftTrigger,
			RightTrigger,
			SelectButton,
			StartButton,
			LeftStickButton,
			RightStickButton
		}

		private static class Patches
		{
			[HarmonyPatch(typeof(ZInput), "Load")]
			[HarmonyPostfix]
			private static void RegisterCustomInputs(ZInput __instance)
			{
				Instance.RegisterCustomInputs(__instance);
			}

			[HarmonyPatch(typeof(ZInput), "GetButtonDown")]
			[HarmonyPostfix]
			private static void ZInput_GetButtonDown(string name, ref bool __result)
			{
				__result = Instance.ZInput_GetButtonDown(name);
			}

			[HarmonyPatch(typeof(ZInput), "GetButton")]
			[HarmonyPostfix]
			private static void ZInput_GetButton(string name, ref bool __result)
			{
				__result = Instance.ZInput_GetButton(name);
			}

			[HarmonyPatch(typeof(ZInput), "GetButtonUp")]
			[HarmonyPostfix]
			private static void ZInput_GetButtonUp(string name, ref bool __result)
			{
				__result = Instance.ZInput_GetButtonUp(name);
			}

			[HarmonyPatch(typeof(ZInput), "GetButtonDown")]
			[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
			public static bool ZInput_GetButtonDown_Original(string name)
			{
				throw new NotImplementedException("It's a stub");
			}

			[HarmonyPatch(typeof(ZInput), "GetButton")]
			[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
			public static bool ZInput_GetButton_Original(string name)
			{
				throw new NotImplementedException("It's a stub");
			}

			[HarmonyPatch(typeof(ZInput), "GetButtonUp")]
			[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
			public static bool ZInput_GetButtonUp_Original(string name)
			{
				throw new NotImplementedException("It's a stub");
			}
		}

		internal static Dictionary<string, ButtonConfig> Buttons;

		internal static Dictionary<ConfigEntryBase, ButtonConfig> ButtonToConfigDict;

		private static InputManager _instance;

		public static InputManager Instance => _instance ?? (_instance = new InputManager());

		public static KeyCode GetGamepadKeyCode(GamepadButton @enum)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return InputUtils.GetGamepadKeyCode(@enum);
		}

		public static GamepadInput GetGamepadInput(GamepadButton @enum)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return InputUtils.GetGamepadInput(@enum);
		}

		public static string GetAxisPath(string axis)
		{
			return InputUtils.GetAxisPath(axis);
		}

		public static string GetGamepadInputPath(GamepadInput input)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return InputUtils.GetGamepadInputPath(input);
		}

		public static string GetGamepadString(GamepadButton @enum)
		{
			return InputUtils.GetGamepadString(@enum);
		}

		public static GamepadButton GetGamepadButton(GamepadInput input)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return InputUtils.GetGamepadButton(input);
		}

		public static GamepadButton GetGamepadButton(string axis)
		{
			return InputUtils.GetGamepadButton(axis);
		}

		public static GamepadButton GetGamepadButton(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return InputUtils.GetGamepadButton(key);
		}

		private InputManager()
		{
		}

		static InputManager()
		{
			Buttons = new Dictionary<string, ButtonConfig>();
			ButtonToConfigDict = new Dictionary<ConfigEntryBase, ButtonConfig>();
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("InputManager");
			if (!GUIUtils.IsHeadless)
			{
				Main.Harmony.PatchAll(typeof(Patches));
			}
		}

		public void AddButton(string modGuid, ButtonConfig buttonConfig)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (buttonConfig == null)
			{
				throw new ArgumentNullException("buttonConfig");
			}
			if (string.IsNullOrEmpty(modGuid))
			{
				throw new ArgumentException("modGuid can not be empty or null", "modGuid");
			}
			KeyboardShortcut shortcut;
			if (buttonConfig.Config == null && (int)buttonConfig.Key == 0 && buttonConfig.ShortcutConfig == null)
			{
				shortcut = buttonConfig.Shortcut;
				if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0 && buttonConfig.GamepadConfig == null && buttonConfig.GamepadButton == GamepadButton.None && string.IsNullOrEmpty(buttonConfig.Axis))
				{
					throw new ArgumentException("buttonConfig needs either Axis, Key, Gamepad, Shortcut or a Config set.", "buttonConfig");
				}
			}
			if (Buttons.ContainsKey(buttonConfig.Name + "!" + modGuid))
			{
				Logger.LogWarning("Cannot have duplicate button: " + buttonConfig.Name + " (Mod " + modGuid + ")");
				return;
			}
			if ((int)buttonConfig.Key != 0)
			{
				shortcut = buttonConfig.Shortcut;
				if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0)
				{
					Logger.LogWarning("Cannot have both a Key and Shortcut in button config " + buttonConfig.Name + " (Mod " + modGuid + ")");
					return;
				}
			}
			if (buttonConfig.Config != null && buttonConfig.ShortcutConfig != null)
			{
				Logger.LogWarning("Cannot have both a Key and Shortcut config in button config " + buttonConfig.Name + " (Mod " + modGuid + ")");
				return;
			}
			if (buttonConfig.Config != null)
			{
				ButtonToConfigDict.Add((ConfigEntryBase)(object)buttonConfig.Config, buttonConfig);
			}
			if (buttonConfig.ShortcutConfig != null)
			{
				ButtonToConfigDict.Add((ConfigEntryBase)(object)buttonConfig.ShortcutConfig, buttonConfig);
			}
			if (buttonConfig.GamepadConfig != null)
			{
				ButtonToConfigDict.Add((ConfigEntryBase)(object)buttonConfig.GamepadConfig, buttonConfig);
			}
			buttonConfig.Name = buttonConfig.Name + "!" + modGuid;
			Buttons.Add(buttonConfig.Name, buttonConfig);
		}

		private void RegisterCustomInputs(ZInput self)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if (!Buttons.Any())
			{
				return;
			}
			Logger.LogInfo($"Registering {Buttons.Count} custom inputs");
			foreach (KeyValuePair<string, ButtonConfig> button in Buttons)
			{
				ButtonConfig value = button.Value;
				if (!string.IsNullOrEmpty(value.Axis))
				{
					self.AddButton(value.Name, GetAxisPath(value.Axis), false, true, true, value.RepeatDelay, value.RepeatInterval);
				}
				else if ((int)value.Key != 0)
				{
					self.AddButton(value.Name, ZInput.KeyCodeToPath(value.Key, false), false, true, true, value.RepeatDelay, value.RepeatInterval);
				}
				else
				{
					KeyboardShortcut shortcut = value.Shortcut;
					if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0)
					{
						string name = value.Name;
						shortcut = value.Shortcut;
						self.AddButton(name, ZInput.KeyCodeToPath(((KeyboardShortcut)(ref shortcut)).MainKey, false), false, true, true, value.RepeatDelay, value.RepeatInterval);
					}
				}
				if (value.GamepadButton != GamepadButton.None)
				{
					GamepadInput gamepadInput = GetGamepadInput(value.GamepadButton);
					if ((int)gamepadInput != 0)
					{
						string text = "Joy!" + value.Name;
						self.AddButton(text, GetGamepadInputPath(gamepadInput), false, true, true, value.RepeatDelay, value.RepeatInterval);
					}
				}
				Logger.LogDebug("Registered input " + button.Key);
			}
		}

		private bool ZInput_GetButtonDown(string name)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!Patches.ZInput_GetButtonDown_Original(name) && !Patches.ZInput_GetButtonDown_Original("Joy!" + name))
			{
				return false;
			}
			if (!Buttons.TryGetValue(name, out var value))
			{
				return true;
			}
			KeyboardShortcut shortcut = value.Shortcut;
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0)
			{
				shortcut = value.Shortcut;
				if (!((KeyboardShortcut)(ref shortcut)).IsDown())
				{
					return false;
				}
			}
			return TakeInput(value);
		}

		private bool ZInput_GetButton(string name)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!Patches.ZInput_GetButton_Original(name) && !Patches.ZInput_GetButton_Original("Joy!" + name))
			{
				return false;
			}
			if (!Buttons.TryGetValue(name, out var value))
			{
				return true;
			}
			KeyboardShortcut shortcut = value.Shortcut;
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0)
			{
				shortcut = value.Shortcut;
				if (!((KeyboardShortcut)(ref shortcut)).IsPressed())
				{
					return false;
				}
			}
			return TakeInput(value);
		}

		private bool ZInput_GetButtonUp(string name)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!Patches.ZInput_GetButtonUp_Original(name) && !Patches.ZInput_GetButtonUp_Original("Joy!" + name))
			{
				return false;
			}
			if (!Buttons.TryGetValue(name, out var value))
			{
				return true;
			}
			KeyboardShortcut shortcut = value.Shortcut;
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0)
			{
				shortcut = value.Shortcut;
				if (!((KeyboardShortcut)(ref shortcut)).IsUp())
				{
					return false;
				}
			}
			return TakeInput(value);
		}

		private bool TakeInput(ButtonConfig button)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return true;
			}
			if (button.BlockOtherInputs && ZInput.instance.m_buttons.TryGetValue(button.Name, out var def))
			{
				foreach (KeyValuePair<string, ButtonDef> item in ZInput.instance.m_buttons.Where((KeyValuePair<string, ButtonDef> pair) => IsSameButton(def, pair.Value)))
				{
					ZInput.ResetButtonStatus(item.Key);
					item.Value.m_pressedDynamic = false;
					item.Value.m_pressedFixed = false;
				}
			}
			if (button.ActiveInGUI && !GUIManager.InputBlocked)
			{
				return true;
			}
			if (button.ActiveInCustomGUI && GUIManager.InputBlocked)
			{
				return true;
			}
			return ((Character)Player.m_localPlayer).TakeInput();
		}

		private static bool IsSameButton(ButtonDef buttonA, ButtonDef buttonB)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			IEnumerable<string> first = ((IEnumerable<InputBinding>)(object)buttonA.ButtonAction.bindings).Select((InputBinding binding) => ((InputBinding)(ref binding)).path);
			IEnumerable<string> second = ((IEnumerable<InputBinding>)(object)buttonB.ButtonAction.bindings).Select((InputBinding binding) => ((InputBinding)(ref binding)).path);
			return first.Intersect(second).Any();
		}
	}
	public class ItemManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
			[HarmonyPrefix]
			[HarmonyPriority(-100)]
			private static void RegisterCustomDataFejd(ObjectDB __instance, ObjectDB other)
			{
				Instance.RegisterCustomDataFejd(__instance, other);
			}

			[HarmonyPatch(typeof(ObjectDB), "Awake")]
			[HarmonyPrefix]
			private static void RegisterCustomData(ObjectDB __instance)
			{
				Instance.RegisterCustomData(__instance);
			}

			[HarmonyPatch(typeof(Player), "OnSpawned")]
			[HarmonyPostfix]
			private static void ReloadKnownRecipes(Player __instance)
			{
				Instance.ReloadKnownRecipes(__instance);
			}

			[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
			[HarmonyPostfix]
			[HarmonyPriority(0)]
			private static void InvokeOnItemsRegisteredFejd()
			{
				Instance.InvokeOnItemsRegisteredFejd();
			}

			[HarmonyPatch(typeof(ObjectDB), "Awake")]
			[HarmonyPostfix]
			[HarmonyPriority(0)]
			private static void InvokeOnItemsRegistered()
			{
				Instance.InvokeOnItemsRegistered();
			}
		}

		private static ItemManager _instance;

		internal readonly Dictionary<string, CustomItem> Items = new Dictionary<string, CustomItem>();

		internal readonly HashSet<CustomRecipe> Recipes = new HashSet<CustomRecipe>();

		internal readonly HashSet<CustomStatusEffect> StatusEffects = new HashSet<CustomStatusEffect>();

		internal readonly HashSet<CustomItemConversion> ItemConversions = new HashSet<CustomItemConversion>();

		public static ItemManager Instance => _instance ?? (_instance = new ItemManager());

		[Obsolete("Use PrefabManager.OnVanillaPrefabsAvailable instead")]
		public static event Action OnVanillaItemsAvailable;

		internal static event Action OnKitbashItemsAvailable;

		public static event Action OnItemsRegisteredFejd;

		public static event Action OnItemsRegistered;

		private ItemManager()
		{
		}

		static ItemManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("ItemManager");
			Main.Harmony.PatchAll(typeof(Patches));
			PrefabManager.Instance.Activate();
		}

		public bool AddItem(CustomItem customItem)
		{
			if (!customItem.IsValid())
			{
				Logger.LogWarning(customItem.SourceMod, $"Custom item {customItem} is not valid");
				return false;
			}
			if (Items.ContainsKey(((Object)customItem.ItemPrefab).name))
			{
				Logger.LogWarning(customItem.SourceMod, $"Custom item {customItem} already added");
				return false;
			}
			if (!PrefabManager.Instance.AddPrefab(customItem.ItemPrefab, customItem.SourceMod))
			{
				return false;
			}
			if (customItem.ItemPrefab.layer == 0)
			{
				customItem.ItemPrefab.layer = LayerMask.NameToLayer("item");
			}
			Items.Add(((Object)customItem.ItemPrefab).name, customItem);
			if (customItem.Recipe != null)
			{
				AddRecipe(customItem.Recipe);
			}
			if (Object.op_Implicit((Object)(object)PrefabManager.Instance.MenuObjectDB))
			{
				RegisterItemInObjectDB(PrefabManager.Instance.MenuObjectDB, customItem.ItemPrefab, customItem.SourceMod);
			}
			return true;
		}

		public CustomItem GetItem(string itemName)
		{
			if (Items.TryGetValue(itemName, out var value))
			{
				return value;
			}
			return null;
		}

		public void RemoveItem(string itemName)
		{
			CustomItem item = GetItem(itemName);
			if (item == null)
			{
				Logger.LogWarning("Could not remove item " + itemName + ": Not found");
			}
			else
			{
				RemoveItem(item);
			}
		}

		public void RemoveItem(CustomItem item)
		{
			Items.Remove(((Object)item.ItemPrefab).name);
			if (Object.op_Implicit((Object)(object)ObjectDB.instance) && Object.op_Implicit((Object)(object)item.ItemPrefab))
			{
				ObjectDB.instance.m_items.Remove(item.ItemPrefab);
				ObjectDB.instance.m_itemByHash.Remove(StringExtensionMethods.GetStableHashCode(((Object)item.ItemPrefab).name));
			}
			if (Object.op_Implicit((Object)(object)item.ItemPrefab))
			{
				PrefabManager.Instance.RemovePrefab(((Object)item.ItemPrefab).name);
			}
			if (item.Recipe != null)
			{
				RemoveRecipe(item.Recipe);
			}
		}

		public bool AddRecipe(CustomRecipe customRecipe)
		{
			if (!customRecipe.IsValid())
			{
				Logger.LogWarning(customRecipe.SourceMod, $"Custom recipe {customRecipe} is not valid");
				return false;
			}
			if (Recipes.Contains(customRecipe))
			{
				Logger.LogWarning(customRecipe.SourceMod, $"Custom recipe {customRecipe} already added");
				return false;
			}
			Recipes.Add(customRecipe);
			return true;
		}

		public void AddRecipesFromJson(string path)
		{
			string text = AssetUtils.LoadText(path);
			if (string.IsNullOrEmpty(text))
			{
				Logger.LogError("Failed to load recipes from invalid JSON: " + path);
				return;
			}
			List<RecipeConfig> list = RecipeConfig.ListFromJson(text);
			foreach (RecipeConfig item in list)
			{
				AddRecipe(new CustomRecipe(item));
			}
		}

		public CustomRecipe GetRecipe(string recipeName)
		{
			return Recipes.FirstOrDefault((CustomRecipe x) => ((Object)x.Recipe).name.Equals(recipeName));
		}

		public void RemoveRecipe(string recipeName)
		{
			CustomRecipe recipe = GetRecipe(recipeName);
			if (recipe == null)
			{
				Logger.LogWarning("Could not remove recipe " + recipeName + ": Not found");
			}
			else
			{
				RemoveRecipe(recipe);
			}
		}

		public void RemoveRecipe(CustomRecipe recipe)
		{
			Recipes.Remove(recipe);
			if (Object.op_Implicit((Object)(object)ObjectDB.instance) && Object.op_Implicit((Object)(object)recipe.Recipe))
			{
				ObjectDB.instance.m_recipes.Remove(recipe.Recipe);
			}
		}

		public bool AddStatusEffect(CustomStatusEffect customStatusEffect)
		{
			if (!customStatusEffect.IsValid())
			{
				Logger.LogWarning(customStatusEffect.SourceMod, $"Custom status effect {customStatusEffect} is not valid");
				return false;
			}
			if (StatusEffects.Contains(customStatusEffect))
			{
				Logger.LogWarning(customStatusEffect.SourceMod, $"Custom status effect {customStatusEffect} already added");
				return false;
			}
			StatusEffects.Add(customStatusEffect);
			return true;
		}

		public bool AddItemConversion(CustomItemConversion itemConversion)
		{
			if (!itemConversion.IsValid())
			{
				Logger.LogWarning(itemConversion.SourceMod, $"Custom item conversion {itemConversion} is not valid");
				return false;
			}
			if (ItemConversions.Contains(itemConversion))
			{
				Logger.LogWarning(itemConversion.SourceMod, $"Custom item conversion {itemConversion} already added");
				return false;
			}
			ItemConversions.Add(itemConversion);
			return true;
		}

		public bool RemoveItemConversion(CustomItemConversion itemConversion)
		{
			if (!ItemConversions.Contains(itemConversion))
			{
				Logger.LogWarning($"Could not remove item conversion {itemConversion}: not found");
				return false;
			}
			ItemConversions.Remove(itemConversion);
			return true;
		}

		private void RegisterCustomItems(ObjectDB objectDB)
		{
			if (Items.Count <= 0)
			{
				return;
			}
			Logger.LogInfo($"Adding {Items.Count} custom items to the ObjectDB");
			List<CustomItem> list = new List<CustomItem>();
			foreach (CustomItem value in Items.Values)
			{
				try
				{
					ItemDrop itemDrop = value.ItemDrop;
					if (value.FixReference || value.FixConfig)
					{
						value.ItemPrefab.FixReferences(value.FixReference);
						((object)itemDrop.m_itemData.m_shared).FixReferences();
						value.FixVariants();
						value.FixReference = false;
						value.FixConfig = false;
					}
					if (!Object.op_Implicit((Object)(object)itemDrop.m_itemData.m_dropPrefab))
					{
						itemDrop.m_itemData.m_dropPrefab = value.ItemPrefab;
					}
					RegisterItemInObjectDB(objectDB, value.ItemPrefab, value.SourceMod);
				}
				catch (Exception arg)
				{
					Logger.LogWarning(value?.SourceMod, $"Error caught while adding item {value}: {arg}");
					list.Add(value);
				}
			}
			foreach (CustomItem item in list)
			{
				if (Object.op_Implicit((Object)(object)item.ItemPrefab))
				{
					PrefabManager.Instance.DestroyPrefab(((Object)item.ItemPrefab).name);
				}
				RemoveItem(item);
			}
		}

		public void RegisterItemInObjectDB(GameObject prefab)
		{
			RegisterItemInObjectDB(ObjectDB.instance, prefab, BepInExUtils.GetSourceModMetadata());
		}

		private void RegisterItemInObjectDB(ObjectDB objectDB, GameObject prefab, BepInPlugin sourceMod)
		{
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				throw new Exception("Prefab " + ((Object)prefab).name + " has no ItemDrop component attached");
			}
			string name = ((Object)prefab).name;
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (objectDB.m_itemByHash.ContainsKey(stableHashCode))
			{
				Logger.LogDebug("Already added item " + ((Object)prefab).name);
			}
			else
			{
				if (!PrefabManager.Instance.Prefabs.ContainsKey(name))
				{
					PrefabManager.Instance.AddPrefab(prefab, sourceMod);
				}
				if ((Object)(object)ZNetScene.instance != (Object)null && !ZNetScene.instance.m_namedPrefabs.ContainsKey(stableHashCode))
				{
					PrefabManager.Instance.RegisterToZNetScene(prefab);
				}
				objectDB.m_items.Add(prefab);
				objectDB.m_itemByHash.Add(stableHashCode, prefab);
			}
			Logger.LogDebug("Added item " + ((Object)prefab).name + " | Token: " + component.TokenName());
		}

		private void RegisterCustomRecipes(ObjectDB objectDB)
		{
			if (!Recipes.Any())
			{
				return;
			}
			Logger.LogInfo($"Adding {Recipes.Count} custom recipes to the ObjectDB");
			List<CustomRecipe> list = new List<CustomRecipe>();
			foreach (CustomRecipe recipe2 in Recipes)
			{
				try
				{
					Recipe recipe = recipe2.Recipe;
					if (recipe2.FixReference || recipe2.FixRequirementReferences)
					{
						((object)recipe).FixReferences();
						recipe2.FixReference = false;
						recipe2.FixRequirementReferences = false;
					}
					objectDB.m_recipes.Add(recipe);
					Logger.LogDebug("Added recipe for " + recipe.m_item.TokenName());
				}
				catch (Exception arg)
				{
					Logger.LogWarning(recipe2?.SourceMod, $"Error caught while adding recipe {recipe2}: {arg}");
					list.Add(recipe2);
				}
			}
			foreach (CustomRecipe item in list)
			{
				Recipes.Remove(item);
			}
		}

		private void RegisterCustomStatusEffects(ObjectDB objectDB)
		{
			if (!StatusEffects.Any())
			{
				return;
			}
			Logger.LogInfo($"Adding {StatusEffects.Count} custom status effects to the ObjectDB");
			List<CustomStatusEffect> list = new List<CustomStatusEffect>();
			foreach (CustomStatusEffect statusEffect2 in StatusEffects)
			{
				try
				{
					StatusEffect statusEffect = statusEffect2.StatusEffect;
					if (statusEffect2.FixReference)
					{
						((object)statusEffect).FixReferences();
						statusEffect2.FixReference = false;
					}
					objectDB.m_StatusEffects.Add(statusEffect);
					Logger.LogDebug($"Added status effect {statusEffect2}");
				}
				catch (Exception arg)
				{
					Logger.LogWarning(statusEffect2?.SourceMod, $"Error caught while adding status effect {statusEffect2}: {arg}");
					list.Add(statusEffect2);
				}
			}
			foreach (CustomStatusEffect item in list)
			{
				StatusEffects.Remove(item);
			}
		}

		private void RegisterCustomItemConversions()
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Expected O, but got Unknown
			if (!ItemConversions.Any())
			{
				return;
			}
			Logger.LogInfo($"Adding {ItemConversions.Count} custom item conversions");
			List<CustomItemConversion> list = new List<CustomItemConversion>();
			foreach (CustomItemConversion itemConversion in ItemConversions)
			{
				try
				{
					GameObject prefab = PrefabManager.Instance.GetPrefab(itemConversion.Config.Station);
					if (!Object.op_Implicit((Object)(object)prefab))
					{
						throw new Exception("Invalid station prefab " + itemConversion.Config.Station);
					}
					if (itemConversion.FixReference)
					{
						((object)itemConversion).FixReferences();
						itemConversion.FixReference = false;
					}
					switch (itemConversion.Type)
					{
					case CustomItemConversion.ConversionType.CookingStation:
					{
						CookingStation component3 = prefab.GetComponent<CookingStation>();
						ItemConversion cookConversion = (ItemConversion)itemConversion.ItemConversion;
						if (component3.m_conversion.Exists((ItemConversion c) => (Object)(object)c.m_from == (Object)(object)cookConversion.m_from))
						{
							Logger.LogDebug($"Already added conversion ${itemConversion}");
							continue;
						}
						component3.m_conversion.Add(cookConversion);
						break;
					}
					case CustomItemConversion.ConversionType.Fermenter:
					{
						Fermenter component2 = prefab.GetComponent<Fermenter>();
						ItemConversion fermenterConversion = (ItemConversion)itemConversion.ItemConversion;
						if (component2.m_conversion.Exists((ItemConversion c) => (Object)(object)c.m_from == (Object)(object)fermenterConversion.m_from))
						{
							Logger.LogDebug($"Already added conversion ${itemConversion}");
							continue;
						}
						component2.m_conversion.Add(fermenterConversion);
						break;
					}
					case CustomItemConversion.ConversionType.Smelter:
					{
						Smelter component4 = prefab.GetComponent<Smelter>();
						ItemConversion smelterConversion = (ItemConversion)itemConversion.ItemConversion;
						if (component4.m_conversion.Exists((ItemConversion c) => (Object)(object)c.m_from == (Object)(object)smelterConversion.m_from))
						{
							Logger.LogDebug($"Already added conversion ${itemConversion}");
							continue;
						}
						component4.m_conversion.Add(smelterConversion);
						break;
					}
					case CustomItemConversion.ConversionType.Incinerator:
					{
						Incinerator component = prefab.GetComponent<Incinerator>();
						IncineratorConversion incineratorConversion = (IncineratorConversion)itemConversion.ItemConversion;
						if (component.m_conversions.Exists((IncineratorConversion c) => c.m_requirements == incineratorConversion.m_requirements))
						{
							Logger.LogDebug($"Already added conversion ${itemConversion}");
							continue;
						}
						component.m_conversions.Add(incineratorConversion);
						break;
					}
					default:
						throw new Exception("Unknown conversion type");
					}
					Logger.LogDebug($"Added item conversion {itemConversion}");
				}
				catch (Exception arg)
				{
					Logger.LogWarning(itemConversion?.SourceMod, $"Error caught while adding item conversion {itemConversion}: {arg}");
					list.Add(itemConversion);
				}
			}
			foreach (CustomItemConversion item in list)
			{
				ItemConversions.Remove(item);
			}
		}

		private void RegisterCustomDataFejd(ObjectDB self, ObjectDB other)
		{
			InvokeOnVanillaItemsAvailable();
			InvokeOnKitbashItemsAvailable();
			UpdateRegistersSafe(other);
			RegisterCustomItems(other);
		}

		[Obsolete]
		private void InvokeOnVanillaItemsAvailable()
		{
			ItemManager.OnVanillaItemsAvailable?.SafeInvoke();
		}

		private void InvokeOnKitbashItemsAvailable()
		{
			ItemManager.OnKitbashItemsAvailable?.SafeInvoke();
		}

		private void InvokeOnItemsRegisteredFejd()
		{
			ItemManager.OnItemsRegisteredFejd?.SafeInvoke();
		}

		private void RegisterCustomData(ObjectDB self)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name == "main")
			{
				UpdateRegistersSafe(self);
				RegisterCustomItems(self);
				RegisterCustomRecipes(self);
				RegisterCustomStatusEffects(self);
				RegisterCustomItemConversions();
			}
		}

		private void InvokeOnItemsRegistered()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name == "main")
			{
				ItemManager.OnItemsRegistered?.SafeInvoke();
			}
		}

		private void ReloadKnownRecipes(Player self)
		{
			if (Items.Count > 0 || Recipes.Count > 0)
			{
				try
				{
					self.UpdateKnownRecipesList();
				}
				catch (Exception arg)
				{
					Logger.LogWarning($"Exception caught while reloading player recipes: {arg}");
				}
			}
		}

		private static void UpdateRegistersSafe(ObjectDB objectDB)
		{
			objectDB.m_itemByHash.Clear();
			objectDB.m_itemByData.Clear();
			foreach (GameObject item in objectDB.m_items)
			{
				if (!Object.op_Implicit((Object)(object)item))
				{
					Logger.LogWarning("Found null item in ObjectDB.m_items");
					continue;
				}
				string name = ((Object)item).name;
				int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
				if (objectDB.m_itemByHash.ContainsKey(stableHashCode))
				{
					BepInPlugin sourceMod = ModQuery.GetPrefab(name)?.SourceMod;
					Logger.LogWarning(sourceMod, $"Found duplicate item '{name}' ({stableHashCode}) in ObjectDB.m_items");
					continue;
				}
				objectDB.m_itemByHash.Add(stableHashCode, item);
				ItemDrop component = item.GetComponent<ItemDrop>();
				if ((Object)(object)component != (Object)null)
				{
					objectDB.m_itemByData[component.m_itemData.m_shared] = item;
				}
			}
		}
	}
	public class KeyHintManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(KeyHints), "Start")]
			[HarmonyPostfix]
			private static void KeyHints_Start(KeyHints __instance)
			{
				try
				{
					Instance.GetBaseGameObjects(__instance);
					Instance.KeyHints_Start(__instance);
				}
				catch (Exception arg)
				{
					Logger.LogWarning($"Exception caught while creating key hint objects: {arg}");
				}
			}

			[HarmonyPatch(typeof(KeyHints), "UpdateHints")]
			[HarmonyPrefix]
			private static bool KeyHints_UpdateHints(KeyHints __instance)
			{
				return Instance.KeyHints_UpdateHints(__instance);
			}

			[HarmonyPatch(typeof(ZInput), "Save")]
			[HarmonyPostfix]
			private static void ZInput_Save(ZInput __instance)
			{
				Instance.ZInput_Save(__instance);
			}
		}

		private static KeyHintManager _instance;

		private readonly Dictionary<string, KeyHintConfig> KeyHints = new Dictionary<string, KeyHintConfig>();

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

		private KeyHints KeyHintInstance;

		private RectTransform KeyHintContainer;

		private GameObject BaseKey;

		private GameObject BaseRotate;

		private GameObject BaseButton;

		private GameObject BaseTrigger;

		private GameObject BaseShoulder;

		private GameObject BaseStick;

		private GameObject BaseDPad;

		private bool HasInitBaseGameObjects;

		public static KeyHintManager Instance => _instance ?? (_instance = new KeyHintManager());

		private KeyHintManager()
		{
		}

		static KeyHintManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("KeyHintManager");
			if (!GUIUtils.IsHeadless)
			{
				Main.Harmony.PatchAll(typeof(Patches));
			}
		}

		public bool AddKeyHint(KeyHintConfig hintConfig)
		{
			if (hintConfig.Item == null)
			{
				Logger.LogWarning($"Key hint config {hintConfig} is not valid");
				return false;
			}
			if (KeyHints.ContainsKey(hintConfig.ToString()))
			{
				Logger.LogWarning($"Key hint config for item {hintConfig} already added");
				return false;
			}
			foreach (ButtonConfig item in hintConfig.ButtonConfigs.Where((ButtonConfig x) => x.IsConfigBacked))
			{
				if (item.Config != null)
				{
					item.Config.SettingChanged += delegate
					{
						hintConfig.Dirty = true;
					};
				}
				if (item.ShortcutConfig != null)
				{
					item.ShortcutConfig.SettingChanged += delegate
					{
						hintConfig.Dirty = true;
					};
				}
				if (item.GamepadConfig != null)
				{
					item.GamepadConfig.SettingChanged += delegate
					{
						hintConfig.Dirty = true;
					};
				}
			}
			KeyHints.Add(hintConfig.ToString(), hintConfig);
			return true;
		}

		public void RemoveKeyHint(KeyHintConfig hintConfig)
		{
			if (KeyHints.ContainsKey(hintConfig.ToString()))
			{
				KeyHints.Remove(hintConfig.ToString());
			}
			if (KeyHintObjects.TryGetValue(hintConfig.ToString(), out var value))
			{
				Object.Destroy((Object)(object)value);
				KeyHintObjects.Remove(hintConfig.ToString());
			}
		}

		private void GetBaseGameObjects(KeyHints self)
		{
			if (HasInitBaseGameObjects)
			{
				return;
			}
			GameObject buildHints = self.m_buildHints;
			UIInputHint component = buildHints.GetComponent<UIInputHint>();
			object obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				GameObject mouseKeyboardHint = component.m_mouseKeyboardHint;
				obj = ((mouseKeyboardHint != null) ? mouseKeyboardHint.transform : null);
			}
			Transform val = (Transform)obj;
			object obj2;
			if (component == null)
			{
				obj2 = null;
			}
			else
			{
				GameObject gamepadHint = component.m_gamepadHint;
				obj2 = ((gamepadHint != null) ? gamepadHint.transform : null);
			}
			Transform val2 = (Transform)obj2;
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				Logger.LogWarning("Could not find child objects for KeyHints");
				return;
			}
			Transform obj3 = ((Component)val).transform.Find("Place");
			GameObject val3 = ((obj3 != null) ? ((Component)obj3).gameObject : null);
			Transform obj4 = ((Component)val).transform.Find("rotate");
			GameObject val4 = ((obj4 != null) ? ((Component)obj4).gameObject : null);
			Transform obj5 = ((Component)val2).transform.Find("Text - BuildMenu");
			GameObject val5 = ((obj5 != null) ? ((Component)obj5).gameObject : null);
			Transform obj6 = ((Component)val2).transform.Find("Text - Place");
			GameObject val6 = ((obj6 != null) ? ((Component)obj6).gameObject : null);
			Transform obj7 = ((Component)val2).transform.Find("Text - Remove");
			GameObject val7 = ((obj7 != null) ? ((Component)obj7).gameObject : null);
			Transform obj8 = ((Component)val2).transform.Find("Text - Rotate");
			GameObject val8 = ((obj8 != null) ? ((Component)obj8).gameObject : null);
			if (!Object.op_Implicit((Object)(object)val3) || !Object.op_Implicit((Object)(object)val4) || !Object.op_Implicit((Object)(object)val5) || !Object.op_Implicit((Object)(object)val6) || !Object.op_Implicit((Object)(object)val7) || !Object.op_Implicit((Object)(object)val8))
			{
				Logger.LogWarning("Could not find child objects for KeyHints");
				return;
			}
			BaseKey = Object.Instantiate<GameObject>(val3);
			((Object)BaseKey).name = "JotunnKeyHintBaseKey";
			PrefabManager.Instance.AddPrefab(BaseKey);
			BaseRotate = Object.Instantiate<GameObject>(val4);
			((Object)BaseRotate).name = "JotunnKeyHintBaseRotate";
			PrefabManager.Instance.AddPrefab(BaseRotate);
			BaseButton = Object.Instantiate<GameObject>(val5);
			((Object)BaseButton).name = "JotunnKeyHintBaseButton";
			PrefabManager.Instance.AddPrefab(BaseButton);
			BaseTrigger = Object.Instantiate<GameObject>(val6);
			((Object)BaseTrigger).name = "JotunnKeyHintBaseTrigger";
			PrefabManager.Instance.AddPrefab(BaseTrigger);
			BaseShoulder = Object.Instantiate<GameObject>(val7);
			((Object)BaseShoulder).name = "JotunnKeyHintBaseShoulder";
			PrefabManager.Instance.AddPrefab(BaseShoulder);
			BaseStick = Object.Instantiate<GameObject>(val8);
			((Object)BaseStick).name = "JotunnKeyHintBaseStick";
			PrefabManager.Instance.AddPrefab(BaseStick);
			BaseDPad = Object.Instantiate<GameObject>(BaseTrigger);
			((Object)BaseDPad).name = "JotunnKeyHintBaseDPad";
			PrefabManager.Instance.AddPrefab(BaseDPad);
			HasInitBaseGameObjects = true;
		}

		private void KeyHints_Start(KeyHints self)
		{
			if (HasInitBaseGameObjects)
			{
				KeyHintInstance = self;
				ref RectTransform keyHintContainer = ref KeyHintContainer;
				Transform transform = ((Component)self).transform;
				keyHintContainer = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				KeyHintObjects.Clear();
			}
		}

		private GameObject CreateKeyHintObject(KeyHintConfig config)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(KeyHintInstance.m_buildHints, (Transform)(object)KeyHintContainer, false);
			((Object)val).name = config.ToString();
			UIInputHint component = val.GetComponent<UIInputHint>();
			object obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				GameObject mouseKeyboardHint = component.m_mouseKeyboardHint;
				obj = ((mouseKeyboardHint != null) ? mouseKeyboardHint.transform : null);
			}
			Transform val2 = (Transform)obj;
			object obj2;
			if (component == null)
			{
				obj2 = null;
			}
			else
			{
				GameObject gamepadHint = component.m_gamepadHint;
				obj2 = ((gamepadHint != null) ? gamepadHint.transform : null);
			}
			Transform val3 = (Transform)obj2;
			if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
			{
				throw new Exception("Could not find child objects for KeyHints");
			}
			foreach (Transform item in val2)
			{
				Transform val4 = item;
				Object.Destroy((Object)(object)((Component)val4).gameObject);
			}
			foreach (Transform item2 in val3)
			{
				Transform val5 = item2;
				Object.Destroy((Object)(object)((Component)val5).gameObject);
			}
			component?.m_inputLayoutSettings.Clear();
			ButtonConfig[] buttonConfigs = config.ButtonConfigs;
			foreach (ButtonConfig buttonConfig in buttonConfigs)
			{
				string text = ZInput.instance.GetBoundKeyString(buttonConfig.Name, true);
				if (string.IsNullOrEmpty(text))
				{
					text = buttonConfig.Name;
				}
				if (text[0].Equals('$'))
				{
					text = LocalizationManager.Instance.TryTranslate(text);
				}
				string text2 = buttonConfig.Hint ?? LocalizationManager.Instance.TryTranslate(buttonConfig.HintToken);
				if (string.IsNullOrEmpty(buttonConfig.Axis) || !buttonConfig.Axis.Equals("Mouse ScrollWheel"))
				{
					GameObject val6 = Object.Instantiate<GameObject>(BaseKey, val2, false);
					((Object)val6).name = buttonConfig.Name;
					((Component)val6.transform.Find("key_bkg/Key")).gameObject.SetText(text);
					((Component)val6.transform.Find("Text")).gameObject.SetText(text2);
					val6.SetActive(true);
				}
				else
				{
					GameObject val7 = Object.Instantiate<GameObject>(BaseRotate, val2, false);
					((Component)val7.transform.Find("Text")).gameObject.SetText(text2);
					val7.SetActive(true);
				}
				InputManager.GamepadButton gamepadButton = buttonConfig.GamepadButton;
				if (gamepadButton == InputManager.GamepadButton.None && ZInput.instance.m_buttons.TryGetValue("Joy" + buttonConfig.Name, out var _))
				{
					gamepadButton = InputManager.GamepadButton.None;
				}
				if (gamepadButton != InputManager.GamepadButton.None)
				{
					string gamepadString = InputManager.GetGamepadString(gamepadButton);
					switch (gamepadButton)
					{
					case InputManager.GamepadButton.DPadLeft:
					case InputManager.GamepadButton.DPadRight:
					{
						GameObject val14 = Object.Instantiate<GameObject>(BaseDPad, val3, false);
						((Object)val14).name = buttonConfig.Name;
						val14.SetActive(true);
						break;
					}
					case InputManager.GamepadButton.DPadUp:
					case InputManager.GamepadButton.DPadDown:
					{
						GameObject val13 = Object.Instantiate<GameObject>(BaseDPad, val3, false);
						((Object)val13).name = buttonConfig.Name;
						val13.SetActive(true);
						break;
					}
					case InputManager.GamepadButton.SelectButton:
					case InputManager.GamepadButton.StartButton:
					{
						GameObject val12 = Object.Instantiate<GameObject>(BaseKey, val3, false);
						((Object)val12).name = buttonConfig.Name;
						val12.SetActive(true);
						break;
					}
					case InputManager.GamepadButton.ButtonSouth:
					case InputManager.GamepadButton.ButtonEast:
					case InputManager.GamepadButton.ButtonWest:
					case InputManager.GamepadButton.ButtonNorth:
					{
						GameObject val11 = Object.Instantiate<GameObject>(BaseButton, val3, false);
						((Object)val11).name = buttonConfig.Name;
						val11.SetActive(true);
						break;
					}
					case InputManager.GamepadButton.LeftShoulder:
					case InputManager.GamepadButton.RightShoulder:
					{
						GameObject val10 = Object.Instantiate<GameObject>(BaseShoulder, val3, false);
						((Object)val10).name = buttonConfig.Name;
						val10.SetActive(true);
						break;
					}
					case InputManager.GamepadButton.LeftTrigger:
					case InputManager.GamepadButton.RightTrigger:
					{
						GameObject val9 = Object.Instantiate<GameObject>(BaseTrigger, val3, false);
						((Object)val9).name = buttonConfig.Name;
						val9.SetActive(true);
						break;
					}
					case InputManager.GamepadButton.LeftStickButton:
					case InputManager.GamepadButton.RightStickButton:
					{
						GameObject val8 = Object.Instantiate<GameObject>(BaseStick, val3, false);
						((Object)val8).name = buttonConfig.Name;
						val8.SetActive(true);
						break;
					}
					default:
						throw new ArgumentOutOfRangeException("gamepadButton", gamepadButton, null);
					}
				}
			}
			KeyHintObjects[config.ToString()] = val;
			config.Dirty = false;
			return val;
		}

		private bool KeyHints_UpdateHints(KeyHints self)
		{
			if (!HasInitBaseGameObjects || (Object)(object)KeyHintInstance == (Object)null || (Object)(object)KeyHintContainer == (Object)null)
			{
				return true;
			}
			if (!UseCustomKeyHint())
			{
				CollectionExtensions.Do<GameObject>(KeyHintObjects.Values.Where((GameObject x) => x.activeSelf), (Action<GameObject>)delegate(GameObject x)
				{
					x.SetActive(false);
				});
				return true;
			}
			return false;
			bool UseCustomKeyHint()
			{
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Invalid comparison between Unknown and I4
				if (!self.m_keyHintsEnabled || !Object.op_Implicit((Object)(object)Player.m_localPlayer) || ((Character)Player.m_localPlayer).IsDead() || Chat.instance.IsChatDialogWindowVisible() || Game.IsPaused() || ((Object)(object)InventoryGui.instance != (Object)null && (InventoryGui.instance.IsSkillsPanelOpen || InventoryGui.instance.IsTrophisPanelOpen || InventoryGui.instance.IsTextPanelOpen || InventoryGui.instance.m_animator.GetBool("visible"))))
				{
					return false;
				}
				ItemData val = null;
				if (((Humanoid)Player.m_localPlayer).m_rightItem != null)
				{
					val = ((Humanoid)Player.m_localPlayer).m_rightItem;
				}
				else if (((Humanoid)Player.m_localPlayer).m_leftItem != null && (int)((Humanoid)Player.m_localPlayer).m_leftItem.m_shared.m_itemType != 15)
				{
					val = ((Humanoid)Player.m_localPlayer).m_leftItem;
				}
				else if (Object.op_Implicit((Object)(object)((Humanoid)Player.m_localPlayer).m_unarmedWeapon))
				{
					val = ((Humanoid)Player.m_localPlayer).m_unarmedWeapon.m_itemData;
				}
				if (val == null || (!val.IsWeapon() && !((Object)(object)val.m_shared?.m_buildPieces != (Object)null)))
				{
					return false;
				}
				GameObject dropPrefab = val.m_dropPrefab;
				string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
				if (string.IsNullOrEmpty(text))
				{
					return false;
				}
				PieceTable buildPieces = Player.m_localPlayer.m_buildPieces;
				object obj;
				if (buildPieces == null)
				{
					obj = null;
				}
				else
				{
					Piece selectedPiece = buildPieces.GetSelectedPiece();
					obj = ((selectedPiece != null) ? ((Object)selectedPiece).name : null);
				}
				string text2 = (string)obj;
				KeyHintConfig value = null;
				if (!string.IsNullOrEmpty(text2))
				{
					KeyHints.TryGetValue(text + ":" + text2, out value);
				}
				if (value == null)
				{
					KeyHints.TryGetValue(text, out value);
				}
				if (value == null)
				{
					return false;
				}
				if (KeyHintObjects.TryGetValue(value.ToString(), out var value2) && value.Dirty)
				{
					Object.DestroyImmediate((Object)(object)value2);
				}
				if (!Object.op_Implicit((Object)(object)value2))
				{
					try
					{
						value2 = CreateKeyHintObject(value);
					}
					catch (Exception arg)
					{
						Logger.LogWarning($"Exception caught while creating KeyHint {value}: {arg}");
						KeyHints.Remove(value.ToString());
						return false;
					}
				}
				if (!value2.activeSelf)
				{
					self.m_buildHints.SetActive(false);
					self.m_combatHints.SetActive(false);
					self.m_inventoryHints.SetActive(false);
					self.m_inventoryWithContainerHints.SetActive(false);
					self.m_fishingHints.SetActive(false);
					CollectionExtensions.Do<GameObject>(KeyHintObjects.Values.Where((GameObject x) => x.activeSelf), (Action<GameObject>)delegate(GameObject x)
					{
						x.SetActive(false);
					});
					value2.SetActive(true);
				}
				return true;
			}
		}

		private void ZInput_Save(ZInput self)
		{
			foreach (KeyHintConfig item in KeyHints.Values.Where((KeyHintConfig x) => x.ButtonConfigs.Any((ButtonConfig y) => !y.IsConfigBacked)))
			{
				item.Dirty = true;
			}
		}
	}
	public class KitbashManager : IManager
	{
		private static KitbashManager _instance;

		private readonly List<KitbashObject> KitbashObjects = new List<KitbashObject>();

		public static KitbashManager Instance => _instance ?? (_instance = new KitbashManager());

		private KitbashManager()
		{
		}

		static KitbashManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("KitbashManager");
			ItemManager.OnKitbashItemsAvailable += ApplyKitbashes;
		}

		public KitbashObject AddKitbash(GameObject prefab, KitbashConfig kitbashConfig)
		{
			if ((Object)(object)prefab.transform.parent == (Object)null)
			{
				string name = ((Object)prefab).name;
				prefab = Object.Instantiate<GameObject>(prefab, PrefabManager.Instance.PrefabContainer.transform);
				((Object)prefab).name = name;
			}
			KitbashObject kitbashObject = new KitbashObject
			{
				Config = kitbashConfig,
				Prefab = prefab
			};
			KitbashObjects.Add(kitbashObject);
			return kitbashObject;
		}

		private void ApplyKitbashes()
		{
			if (KitbashObjects.Count <= 0)
			{
				return;
			}
			Logger.LogInfo($"Applying Kitbash in {KitbashObjects.Count} objects");
			foreach (KitbashObject kitbashObject in KitbashObjects)
			{
				try
				{
					if (kitbashObject.Config.FixReferences)
					{
						kitbashObject.Prefab.FixReferences();
					}
					ApplyKitbash(kitbashObject);
				}
				catch (Exception data)
				{
					Logger.LogError(kitbashObject.SourceMod, data);
				}
			}
			ItemManager.OnKitbashItemsAvailable -= ApplyKitbashes;
		}

		private bool ApplyKitbash(KitbashObject kitbashObject)
		{
			foreach (KitbashSourceConfig kitbashSource in kitbashObject.Config.KitbashSources)
			{
				if (!Instance.Kitbash(kitbashObject, kitbashSource))
				{
					Logger.LogWarning(kitbashObject.SourceMod, $"Kitbash failed for {kitbashObject}");
					return false;
				}
			}
			if (kitbashObject.Config.Layer != null)
			{
				int layer = LayerMask.NameToLayer(kitbashObject.Config.Layer);
				Transform[] componentsInChildren = kitbashObject.Prefab.GetComponentsInChildren<Transform>();
				foreach (Transform val in componentsInChildren)
				{
					((Component)val).gameObject.layer = layer;
				}
			}
			kitbashObject.OnKitbashApplied?.SafeInvoke();
			return true;
		}

		private bool Kitbash(KitbashObject kitbashObject, KitbashSourceConfig config)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = PrefabManager.Instance.GetPrefab(config.SourcePrefab);
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				Logger.LogWarning(kitbashObject.SourceMod, "Prefab '" + config.SourcePrefab + "' not found for " + config.ToString());
				return false;
			}
			Transform val = prefab.transform.Find(config.SourcePath);
			if (!Object.op_Implicit((Object)(object)val))
			{
				Logger.LogWarning(kitbashObject.SourceMod, "Source path '" + config.SourcePath + "' not found for " + config.ToString());
				return false;
			}
			GameObject prefab2 = kitbashObject.Prefab;
			Transform val2 = ((config.TargetParentPath != null) ? prefab2.transform.Find(config.TargetParentPath) : prefab2.transform);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				Logger.LogWarning(kitbashObject.SourceMod, "Target parent not found for " + config.ToString());
				return false;
			}
			GameObject gameObject = ((Component)val).gameObject;
			GameObject val3 = Object.Instantiate<GameObject>(gameObject, val2);
			((Object)val3).name = config.Name ?? ((Object)gameObject).name;
			val3.transform.localPosition = config.Position;
			val3.transform.localRotation = config.Rotation;
			val3.transform.localScale = config.Scale;
			if (config.Materials != null)
			{
				Material[] sourceMaterials = GetSourceMaterials(config);
				if (sourceMaterials == null)
				{
					Logger.LogWarning(kitbashObject.SourceMod, "No materials found for " + config.ToString());
					return false;
				}
				SkinnedMeshRenderer[] componentsInChildren = val3.GetComponentsInChildren<SkinnedMeshRenderer>();
				SkinnedMeshRenderer[] array = componentsInChildren;
				foreach (SkinnedMeshRenderer val4 in array)
				{
					((Renderer)val4).sharedMaterials = sourceMaterials;
					((Renderer)val4).materials = sourceMaterials;
				}
				MeshRenderer[] componentsInChildren2 = val3.GetComponentsInChildren<MeshRenderer>();
				MeshRenderer[] array2 = componentsInChildren2;
				foreach (MeshRenderer val5 in array2)
				{
					((Renderer)val5).sharedMaterials = sourceMaterials;
					((Renderer)val5).materials = sourceMaterials;
				}
			}
			return true;
		}

		private Material[] GetSourceMaterials(KitbashSourceConfig config)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			Material[] array = (Material[])(object)new Material[config.Materials.Length];
			for (int i = 0; i < config.Materials.Length; i++)
			{
				array[i] = (Material)PrefabManager.Cache.GetPrefab(typeof(Material), config.Materials[i]);
			}
			return array;
		}
	}
	public class LocalizationManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(FejdStartup), "SetupGui")]
			[HarmonyPostfix]
			private static void LoadAndSetupModLanguages()
			{
				Instance.LoadAndSetupModLanguages(Localization.instance);
			}

			[HarmonyPatch(typeof(Localization), "LoadLanguages")]
			[HarmonyPostfix]
			private static void Localization_LoadLanguages(ref List<string> __result)
			{
				Instance.AddLanguages(ref __result);
			}

			[HarmonyPatch(typeof(Localization), "SetupLanguage")]
			[HarmonyPostfix]
			private static void Localization_SetupLanguage(Localization __instance, string language)
			{
				Instance.AddTranslations(__instance, language);
			}
		}

		internal readonly Dictionary<string, CustomLocalization> Localizations = new Dictionary<string, CustomLocalization>();

		public const char TokenFirstChar = '$';

		public const string DefaultLanguage = "English";

		public const string TranslationsFolderName = "Translations";

		public const string CommunityTranslationFileName = "community_translation.json";

		internal const string ForbiddenChars = " (){}[]+-!?/\\\\&%,.:-=<>\n";

		internal static readonly char[] ForbiddenCharsArr;

		private static LocalizationManager _instance;

		internal CustomLocalization JotunnLocalization = new CustomLocalization(((BaseUnityPlugin)Main.Instance).Info.Metadata);

		internal static Func<StringReader, List<List<string>>> DoQuoteLineSplit;

		public static LocalizationManager Instance => _instance ?? (_instance = new LocalizationManager());

		public static event Action OnLocalizationAdded;

		private LocalizationManager()
		{
		}

		static LocalizationManager()
		{
			ForbiddenCharsArr = " (){}[]+-!?/\\\\&%,.:-=<>\n".ToCharArray();
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("LocalizationManager");
			Main.Harmony.PatchAll(typeof(Patches));
			DoQuoteLineSplit = (Func<StringReader, List<List<string>>>)Delegate.CreateDelegate(typeof(Func<StringReader, List<List<string>>>), null, typeof(Localization).GetMethod("DoQuoteLineSplit", (BindingFlags)(-1)));
			AddLocalization(JotunnLocalization);
		}

		private void LoadAndSetupModLanguages(Localization localization)
		{
			AddLanguages(ref localization.m_languages);
			AddTranslations(localization, GetPlayerLanguage());
			InvokeOnLocalizationAdded();
		}

		private void InvokeOnLocalizationAdded()
		{
			LocalizationManager.OnLocalizationAdded?.SafeInvoke();
		}

		private void AddLanguages(ref List<string> result)
		{
			foreach (CustomLocalization value in Localizations.Values)
			{
				foreach (string language in value.GetLanguages())
				{
					if (!result.Contains(language))
					{
						result.Add(language);
					}
				}
			}
		}

		private void AddTranslations(Localization localization, string language)
		{
			foreach (KeyValuePair<string, string> allTranslation in GetAllTranslations("English"))
			{
				localization.AddWord(allTranslation.Key, allTranslation.Value);
			}
			if (string.IsNullOrEmpty(language) || language == "English")
			{
				return;
			}
			foreach (KeyValuePair<string, string> allTranslation2 in GetAllTranslations(language))
			{
				localization.AddWord(allTranslation2.Key, allTranslation2.Value);
			}
		}

		private IEnumerable<KeyValuePair<string, string>> GetAllTranslations(string language)
		{
			return Localizations.Values.SelectMany((CustomLocalization ct) => ct.GetTranslations(in language));
		}

		internal static string GetPlayerLanguage()
		{
			return PlayerPrefs.GetString("language", "English");
		}

		public bool AddLocalization(CustomLocalization customLocalization)
		{
			if (Localizations.ContainsKey(customLocalization.SourceMod.GUID))
			{
				Logger.LogWarning(customLocalization.SourceMod, $"{customLocalization} already added");
				return false;
			}
			Localizations.Add(customLocalization.SourceMod.GUID, customLocalization);
			return true;
		}

		public CustomLocalization GetLocalization()
		{
			return GetLocalization(BepInExUtils.GetSourceModMetadata());
		}

		internal CustomLocalization GetLocalization(BepInPlugin sourceMod)
		{
			if (Localizations.TryGetValue(sourceMod.GUID, out var value))
			{
				return value;
			}
			value = new CustomLocalization(sourceMod);
			AddLocalization(value);
			return value;
		}

		public string TryTranslate(string word)
		{
			string text = word.TrimStart(new char[1] { '$' });
			string text2;
			foreach (CustomLocalization value in Localizations.Values)
			{
				if (value != JotunnLocalization)
				{
					text2 = value.TryTranslate(word);
					if (IsValidTranslation(text2))
					{
						return text2;
					}
				}
			}
			text2 = JotunnLocalization.TryTranslate(word);
			if (IsValidTranslation(text2))
			{
				return text2;
			}
			if (Localization.m_instance != null)
			{
				return Localization.m_instance.Translate(text);
			}
			return "[" + word + "]";
		}

		private static bool IsValidTranslation(string translation)
		{
			if (!string.IsNullOrEmpty(translation))
			{
				return translation[0] != '[';
			}
			return false;
		}

		[Obsolete("Use AddLocalization(CustomLocalization) instead")]
		public void AddLocalization(LocalizationConfig config)
		{
			GetLocalization().AddTranslation(config.Language, config.Translations);
		}

		[Obsolete("Use AddLocalization(CustomLocalization) instead")]
		public void AddLocalization(string language, Dictionary<string, string> localization)
		{
			GetLocalization().AddTranslation(in language, localization);
		}

		[Obsolete("Use AddLocalization(CustomLocalization) instead")]
		public void AddToken(string token, string value, bool forceReplace = false)
		{
			GetLocalization().AddTranslation(in token, value);
		}

		[Obsolete("Use AddLocalization(CustomLocalization) instead")]
		public void AddToken(string token, string value, string language, bool forceReplace = false)
		{
			GetLocalization().AddTranslation(in language, in token, value);
		}

		[Obsolete("Use AddLocalization(CustomLocalization) instead")]
		public void AddPath(string path, bool isJson = false)
		{
			GetLocalization().AddFileByPath(path, isJson);
		}

		[Obsolete("Use AddLocalization(CustomLocalization) instead")]
		public void AddJson(string language, string fileContent)
		{
			GetLocalization().AddJsonFile(language, fileContent);
		}

		[Obsolete("Use AddLocalization(CustomLocalization) instead")]
		public void AddLanguageFile(string fileContent)
		{
			GetLocalization().AddLanguageFile(fileContent);
		}
	}
	public class MinimapManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(Minimap), "Start")]
			[HarmonyPostfix]
			private static void Start()
			{
				Instance.Minimap_Start();
			}

			[HarmonyPatch(typeof(Minimap), "LoadMapData")]
			[HarmonyPostfix]
			private static void LoadMapData()
			{
				Instance.Minimap_LoadMapData();
			}

			[HarmonyPatch(typeof(Minimap), "CenterMap")]
			[HarmonyPostfix]
			private static void Minimap_CenterMap(Minimap __instance, Vector3 centerPoint)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Instance.Minimap_CenterMap(__instance, centerPoint);
			}

			[HarmonyPatch(typeof(Minimap), "OnDestroy")]
			[HarmonyPostfix]
			private static void Minimap_OnDestroy()
			{
				Instance.Minimap_OnDestroy();
			}
		}

		public class MapOverlay : MapOverlayBase
		{
			internal bool IgnoreFog;

			private Texture2D _overlayTex;

			private bool _enabled;

			private bool _overlayDirty;

			public Texture2D OverlayTex => _overlayTex ?? (_overlayTex = Create(Instance.TransparentTex));

			public bool Enabled
			{
				get
				{
					return _enabled;
				}
				set
				{
					if (_enabled != value)
					{
						_enabled = value;
						Dirty = true;
						if (!IgnoreFog)
						{
							Instance.SetFogDirty();
						}
						Toggle toggle = Toggle;
						if (toggle != null)
						{
							toggle.SetIsOnWithoutNotify(value);
						}
					}
				}
			}

			internal bool Dirty
			{
				get
				{
					if ((Object)(object)_overlayTex != (Object)null)
					{
						return _overlayDirty;
					}
					return false;
				}
				set
				{
					_overlayDirty = value;
				}
			}

			internal MapOverlay()
			{
			}

			internal void SetTextureDirty(Texture2D tex)
			{
				if (!(((Object)tex).name != base.Name) && (Object)(object)tex == (Object)(object)_overlayTex)
				{
					_overlayDirty = true;
					if (!IgnoreFog)
					{
						Instance.SetFogDirty();
					}
				}
			}

			internal void Destroy()
			{
				if ((Object)(object)_overlayTex != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)_overlayTex);
				}
			}
		}

		public class MapDrawing : MapOverlayBase
		{
			private Texture2D _mainTex;

			private Texture2D _heightFilter;

			private Texture2D _forestFilter;

			private Texture2D _fogFilter;

			private bool _enabled;

			private bool _mainDirty;

			private bool _heightDirty;

			private bool _forestDirty;

			private bool _fogDirty;

			public Texture2D MainTex => _mainTex ?? (_mainTex = Create(Minimap.instance.m_mapTexture));

			public Texture2D HeightFilter => _heightFilter ?? (_heightFilter = Create(Minimap.instance.m_heightTexture));

			public Texture2D ForestFilter => _forestFilter ?? (_forestFilter = Create(Minimap.instance.m_forestMaskTexture));

			public Texture2D FogFilter => _fogFilter ?? (_fogFilter = Create(Minimap.instance.m_fogTexture));

			public bool Enabled
			{
				get
				{
					return _enabled;
				}
				set
				{
					if (_enabled != value)
					{
						_enabled = value;
						Dirty = true;
						if (FogEnabled)
						{
							Instance.SetFogDirty();
						}
						Toggle toggle = Toggle;
						if (toggle != null)
						{
							toggle.SetIsOnWithoutNotify(value);
						}
					}
				}
			}

			internal bool MainEnabled => (Object)(object)_mainTex != (Object)null;

			internal bool HeightEnabled => (Object)(object)_heightFilter != (Object)null;

			internal bool ForestEnabled => (Object)(object)_forestFilter != (Object)null;

			internal bool FogEnabled => (Object)(object)_fogFilter != (Object)null;

			internal bool Dirty
			{
				get
				{
					if (!MainDirty && !HeightDirty && !ForestDirty)
					{
						return FogDirty;
					}
					return true;
				}
				set
				{
					_mainDirty = value;
					_heightDirty = value;
					_forestDirty = value;
					_fogDirty = value;
				}
			}

			internal bool MainDirty
			{
				get
				{
					if ((Object)(object)_mainTex != (Object)null)
					{
						return _mainDirty;
					}
					return false;
				}
				set
				{
					_mainDirty = value;
				}
			}

			internal bool HeightDirty
			{
				get
				{
					if ((Object)(object)_heightFilter != (Object)null)
					{
						return _heightDirty;
					}
					return false;
				}
				set
				{
					_heightDirty = value;
				}
			}

			internal bool ForestDirty
			{
				get
				{
					if ((Object)(object)_forestFilter != (Object)null)
					{
						return _forestDirty;
					}
					return false;
				}
				set
				{
					_forestDirty = value;
				}
			}

			internal bool FogDirty
			{
				get
				{
					if ((Object)(object)_fogFilter != (Object)null)
					{
						return _fogDirty;
					}
					return false;
				}
				set
				{
					_fogDirty = value;
				}
			}

			internal MapDrawing()
			{
			}

			internal void SetTextureDirty(Texture2D tex)
			{
				if (((Object)tex).name != base.Name)
				{
					return;
				}
				if ((Object)(object)tex == (Object)(object)_mainTex)
				{
					_mainDirty = true;
				}
				if ((Object)(object)tex == (Object)(object)_heightFilter)
				{
					_heightDirty = true;
				}
				if ((Object)(object)tex == (Object)(object)_forestFilter)
				{
					_forestDirty = true;
				}
				if ((Object)(object)tex == (Object)(object)_fogFilter)
				{
					_fogDirty = true;
					if (FogEnabled)
					{
						Instance.SetFogDirty();
					}
				}
			}

			internal void Destroy()
			{
				if ((Object)(object)_mainTex != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)_mainTex);
				}
				if ((Object)(object)_heightFilter != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)_heightFilter);
				}
				if ((Object)(object)_forestFilter != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)_forestFilter);
				}
				if ((Object)(object)_fogFilter != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)_fogFilter);
				}
			}
		}

		public class MapOverlayBase : CustomEntity
		{
			internal Toggle Toggle;

			public string Name { get; internal set; }

			public int TextureSize { get; internal set; }

			internal MapOverlayBase()
			{
			}

			internal Texture2D Create(Texture2D van)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: 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_002c: Expected O, but got Unknown
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Invalid comparison between Unknown and I4
				Texture2D val = new Texture2D(((Texture)van).width, ((Texture)van).height, van.format, false)
				{
					wrapMode = (TextureWrapMode)1,
					name = Name
				};
				if ((int)val.format != 3)
				{
					Graphics.CopyTexture((Texture)(object)Instance.TransparentTex, (Texture)(object)val);
				}
				else
				{
					Graphics.CopyTexture((Texture)(object)Minimap.instance.m_mapTexture, (Texture)(object)val);
				}
				return val;
			}
		}

		private static MinimapManager _instance;

		public static Color FilterOn;

		public static Color FilterOff;

		public static Color MeadowHeight;

		private const int TextureSize = 2048;

		private readonly Dictionary<string, MapOverlay> Overlays = new Dictionary<string, MapOverlay>();

		private readonly Dictionary<string, MapDrawing> Drawings = new Dictionary<string, MapDrawing>();

		private Texture2D TransparentTex;

		private Sprite CircleMask;

		private Texture2D OverlayTex;

		private Texture2D MainTex;

		private Texture2D HeightFilter;

		private Texture2D ForestFilter;

		private Texture2D FogFilter;

		private Material ComposeOverlayMaterial;

		private Material ComposeMainMaterial;

		private Material ComposeHeightMaterial;

		private Material ComposeForestMaterial;

		private Material ComposeFogMaterial;

		private MinimapOverlayPanel OverlayPanel;

		private GameObject OverlayLarge;

		private GameObject OverlaySmall;

		public static MinimapManager Instance => _instance ?? (_instance = new MinimapManager());

		public static event Action OnVanillaMapAvailable;

		public static event Action OnVanillaMapDataLoaded;

		private MinimapManager()
		{
		}

		static MinimapManager()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			FilterOn = new Color(1f, 0f, 0f, 255f);
			FilterOff = new Color(0f, 0f, 0f, 255f);
			MeadowHeight = new Color(32f, 0f, 0f, 255f);
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			Main.LogInit("MinimapManager");
			if (!GUIUtils.IsHeadless)
			{
				Main.Harmony.PatchAll(typeof(Patches));
				AssetBundle val = AssetUtils.LoadAssetBundleFromResources("minimapmanager", typeof(MinimapManager).Assembly);
				TransparentTex = val.LoadAsset<Texture2D>("2048x2048_clear");
				GameObject prefab = val.LoadAsset<GameObject>("MinimapOverlayPanel");
				PrefabManager.Instance.AddPrefab(new CustomPrefab(prefab, fixReference: false));
				val.Unload(false);
				Main.Harmony.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Texture2D), "Apply", new Type[2]
				{
					typeof(bool),
					typeof(bool)
				}, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(MinimapManager), "Texture2D_Apply", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		public MapOverlay GetMapOverlay(string name, bool ignoreFog = false)
		{
			if (Overlays.ContainsKey(name))
			{
				Logger.LogDebug("Returning existing overlay with name " + name);
				return Overlays[name];
			}
			if (Overlays.Count == 0)
			{
				SetupOverlays();
			}
			MapOverlay mapOverlay = new MapOverlay
			{
				Name = name,
				Enabled = true,
				TextureSize = 2048,
				IgnoreFog = ignoreFog
			};
			Overlays.Add(name, mapOverlay);
			AddOverlayToGUI(mapOverlay);
			return mapOverlay;
		}

		public MapDrawing GetMapDrawing(string name)
		{
			if (Drawings.ContainsKey(name))
			{
				Logger.LogDebug("Returning existing overlay with name " + name);
				return Drawings[name];
			}
			if (Drawings.Count == 0)
			{
				SetupDrawings();
			}
			MapDrawing mapDrawing = new MapDrawing
			{
				Name = name,
				Enabled = true,
				TextureSize = 2048
			};
			Drawings.Add(name, mapDrawing);
			AddDrawingToGUI(mapDrawing);
			return mapDrawing;
		}

		public bool RemoveMapOverlay(string name)
		{
			return Overlays.Remove(name);
		}

		public bool RemoveMapDrawing(string name)
		{
			return Drawings.Remove(name);
		}

		public List<string> GetOverlayNames()
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, MapOverlay> overlay in Overlays)
			{
				list.Add(overlay.Value.Name);
			}
			return list;
		}

		public List<string> GetDrawingNames()
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, MapDrawing> drawing in Drawings)
			{
				list.Add(drawing.Value.Name);
			}
			return list;
		}

		public Vector2 WorldToOverlayCoords(Vector3 input, int texSize)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			float num = default(float);
			float num2 = default(float);
			Minimap.instance.WorldToMapPoint(input, ref num, ref num2);
			return new Vector2((float)Math.Round(num * (float)texSize), (float)Math.Round(num2 * (float)texSize));
		}

		public Vector3 OverlayToWorldCoords(Vector2 input, int texSize)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			input.x /= texSize;
			input.y /= texSize;
			return Minimap.instance.MapPointToWorld(input.x, input.y);
		}

		private void Minimap_Start()
		{
			SetupGUI();
			StartWatchdog();
			InvokeOnVanillaMapAvailable();
		}

		private void InvokeOnVanillaMapAvailable()
		{
			MinimapManager.OnVanillaMapAvailable?.SafeInvoke();
		}

		private void Minimap_LoadMapData()
		{
			InvokeOnVanillaMapDataLoaded();
		}

		private void InvokeOnVanillaMapDataLoaded()
		{
			MinimapManager.OnVanillaMapDataLoaded?.SafeInvoke();
		}

		private void StartWatchdog()
		{
			((MonoBehaviour)Minimap.instance).StartCoroutine(watchdog());
			IEnumerator watchdog()
			{
				WaitForEndOfFrame wait = new WaitForEndOfFrame();
				while (true)
				{
					yield return wait;
					if (Overlays.Values.Any((MapOverlay x) => x.Dirty) || Drawings.Values.Any((MapDrawing x) => x.Dirty))
					{
						if (Overlays.Values.Any((MapOverlay x) => !x.IgnoreFog && x.Dirty) || Drawings.Values.Any((MapDrawing x) => x.FogEnabled && x.FogDirty))
						{
							Graphics.CopyTexture((Texture)(object)Minimap.instance.m_fogTexture, (Texture)(object)FogFilter);
						}
						if (Drawings.Values.Any((MapDrawing x) => x.FogDirty))
						{
							yield return DrawFogFilter();
						}
						if (Overlays.Values.Any((MapOverlay x) => x.Dirty))
						{
							yield return DrawOverlay();
						}
						if (Drawings.Values.Any((MapDrawing x) => x.MainDirty))
						{
							yield return DrawMain();
						}
						if (Drawings.Values.Any((MapDrawing x) => x.HeightDirty))
						{
							yield return DrawHeightFilter();
						}
						if (Drawings.Values.Any((MapDrawing x) => x.ForestDirty))
						{
							yield return DrawForestFilter();
						}
					}
				}
			}
		}

		private IEnumerator DrawFogFilter()
		{
			Logger.LogDebug("Redraw Fog");
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			foreach (MapDrawing value in Drawings.Values)
			{
				if (value.Enabled && value.FogEnabled)
				{
					DrawLayer(value.FogFilter, FogFilter, ComposeFogMaterial, (RenderTextureFormat)7);
				}
				value.FogDirty = false;
			}
			stopwatch.Stop();
			Logger.LogDebug($"DrawFog loop took {stopwatch.ElapsedMilliseconds}ms time");
			yield return null;
		}

		private IEnumerator DrawOverlay()
		{
			Logger.LogDebug("Redraw Overlay");
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			Graphics.CopyTexture((Texture)(object)TransparentTex, (Texture)(object)OverlayTex);
			foreach (MapOverlay item in Overlays.Values.OrderBy((MapOverlay x) => x.IgnoreFog ? 1 : 0))
			{
				if (item.Enabled)
				{
					ComposeOverlayMaterial.SetTexture("_FogTex", (Texture)(object)(item.IgnoreFog ? TransparentTex : FogFilter));
					DrawLayer(item.OverlayTex, OverlayTex, ComposeOverlayMaterial, (RenderTextureFormat)7);
				}
				item.Dirty = false;
			}
			stopwatch.Stop();
			Logger.LogDebug($"DrawOverlay loop took {stopwatch.ElapsedMilliseconds}ms time");
			yield return null;
		}

		private IEnumerator DrawMain()
		{
			Logger.LogDebug("Redraw Main");
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			Graphics.CopyTexture((Texture)(object)Minimap.instance.m_mapTexture, (Texture)(object)MainTex);
			foreach (MapDrawing value in Drawings.Values)
			{
				if (value.Enabled && value.MainEnabled)
				{
					DrawLayer(value.MainTex, MainTex, ComposeMainMaterial, (RenderTextureFormat)7);
				}
				value.MainDirty = false;
			}
			stopwatch.Stop();
			Logger.LogDebug($"DrawMain loop took {stopwatch.ElapsedMilliseconds}ms time");
			yield return null;
		}

		private IEnumerator DrawHeightFilter()
		{
			Logger.LogDebug("Redraw Height");
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			Graphics.CopyTexture((Texture)(object)Minimap.instance.m_heightTexture, (Texture)(object)HeightFilter);
			foreach (MapDrawing value in Drawings.Values)
			{
				if (value.Enabled && value.HeightEnabled)
				{
					DrawLayer(value.HeightFilter, HeightFilter, ComposeHeightMaterial, (RenderTextureFormat)14);
				}
				value.HeightDirty = false;
			}
			stopwatch.Stop();
			Logger.LogDebug($"DrawHeight loop took {stopwatch.ElapsedMilliseconds}ms time");
			yield return null;
		}

		private IEnumerator DrawForestFilter()
		{
			Logger.LogDebug("Redraw Forest");
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			Graphics.CopyTexture((Texture)(object)Minimap.instance.m_forestMaskTexture, (Texture)(object)ForestFilter);
			foreach (MapDrawing value in Drawings.Values)
			{
				if (value.Enabled && value.ForestEnabled)
				{
					DrawLayer(value.ForestFilter, ForestFilter, ComposeForestMaterial, (RenderTextureFormat)7);
				}
				value.ForestDirty = false;
			}
			stopwatch.Stop();
			Logger.LogDebug($"DrawForest loop took {stopwatch.ElapsedMilliseconds}ms time");
			yield return null;
		}

		private void DrawLayer(Texture2D layer, Texture2D dest, Material mat, RenderTextureFormat format = (RenderTextureFormat)7)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			RenderTexture temporary = RenderTexture.GetTemporary(2048, 2048, 0, format, (RenderTextureReadWrite)0);
			if ((Object)(object)mat != (Object)null)
			{
				Graphics.Blit((Texture)(object)layer, temporary, mat);
			}
			else
			{
				Graphics.Blit((Texture)(object)layer, temporary);
			}
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = temporary;
			dest.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
			dest.Apply();
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(temporary);
		}

		private bool DrawingsActive()
		{
			return Drawings.Count > 0;
		}

		private void SetupDrawings()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			Logger.LogDebug("Setting up MapDrawings");
			MainTex = new Texture2D(2048, 2048, Minimap.instance.m_mapTexture.format, false);
			HeightFilter = new Texture2D(2048, 2048, Minimap.instance.m_heightTexture.format, false);
			ForestFilter = new Texture2D(2048, 2048, Minimap.instance.m_forestMaskTexture.format, false);
			if (FogFilter == null)
			{
				FogFilter = new Texture2D(2048, 2048, Minimap.instance.m_fogTexture.format, false);
			}
			AssetBundle val = AssetUtils.LoadAssetBundleFromResources("minimapmanager", typeof(MinimapManager).Assembly);
			Shader val2 = val.LoadAsset<Shader>("MinimapComposeMain");
			Shader val3 = val.LoadAsset<Shader>("MinimapComposeHeight");
			Shader val4 = val.LoadAsset<Shader>("MinimapComposeForest");
			Shader val5 = val.LoadAsset<Shader>("MinimapComposeFog");
			val.Unload(false);
			ComposeMainMaterial = new Material(val2);
			ComposeHeightMaterial = new Material(val3);
			ComposeForestMaterial = new Material(val4);
			ComposeFogMaterial = new Material(val5);
			ComposeMainMaterial.SetTexture("_VanillaTex", (Texture)(object)MainTex);
			ComposeHeightMaterial.SetTexture("_VanillaTex", (Texture)(object)HeightFilter);
			ComposeForestMaterial.SetTexture("_VanillaTex", (Texture)(object)ForestFilter);
			ComposeFogMaterial.SetTexture("_VanillaTex", (Texture)(object)FogFilter);
			Graphics.CopyTexture((Texture)(object)Minimap.instance.m_mapTexture, (Texture)(object)MainTex);
			Graphics.CopyTexture((Texture)(object)Minimap.instance.m_heightTexture, (Texture)(object)HeightFilter);
			Graphics.CopyTexture((Texture)(object)Minimap.instance.m_forestMaskTexture, (Texture)(object)ForestFilter);
			Graphics.CopyTexture((Texture)(object)Minimap.instance.m_fogTexture, (Texture)(object)FogFilter);
			Minimap.instance.m_mapLargeShader.SetTexture("_MainTex", (Texture)(object)MainTex);
			Minimap.instance.m_mapSmallShader.SetTexture("_MainTex", (Texture)(object)MainTex);
			Minimap.instance.m_mapLargeShader.SetTexture("_HeightTex", (Texture)(object)HeightFilter);
			Minimap.instance.m_mapSmallShader.SetTexture("_HeightTex", (Texture)(object)HeightFilter);
			Minimap.instance.m_mapLargeShader.SetTexture("_MaskTex", (Texture)(object)ForestFilter);
			Minimap.instance.m_mapSmallShader.SetTexture("_MaskTex", (Texture)(object)ForestFilter);
			Minimap.instance.m_mapLargeShader.SetTexture("_FogTex", (Texture)(object)FogFilter);
			Minimap.instance.m_mapSmallShader.SetTexture("_FogTex", (Texture)(object)FogFilter);
			stopwatch.Stop();
			Logger.LogDebug($"Setup took {stopwatch.ElapsedMilliseconds}ms time");
		}

		private void SetupOverlays()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			Logger.LogDebug("Setting up MapOverlays");
			OverlayTex = new Texture2D(2048, 2048, (TextureFormat)4, false);
			if (FogFilter == null)
			{
				FogFilter = new Texture2D(2048, 2048, Minimap.instance.m_fogTexture.format, false);
			}
			AssetBundle val = AssetUtils.LoadAssetBundleFromResources("minimapmanager", typeof(MinimapManager).Assembly);
			CircleMask = val.LoadAsset<Sprite>("CircleMask");
			Shader val2 = val.LoadAsset<Shader>("MinimapComposeOverlay");
			ComposeOverlayMaterial = new Material(val2);
			ComposeOverlayMaterial.SetTexture("_VanillaTex", (Texture)(object)OverlayTex);
			ComposeOverlayMaterial.SetTexture("_FogTex", (Texture)(object)FogFilter);
			val.Unload(false);
			Graphics.CopyTexture((Texture)(object)TransparentTex, (Texture)(object)OverlayTex);
			Graphics.CopyTexture((Texture)(object)Minimap.instance.m_fogTexture, (Texture)(object)FogFilter);
			OverlayLarge = new GameObject("CustomLayerLarge");
			RectTransform val3 = OverlayLarge.AddComponent<RectTransform>();
			((Transform)val3).SetParent(((Component)Minimap.instance.m_mapImageLarge).transform, false);
			((Transform)val3).SetAsFirstSibling();
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.offsetMin = Vector2.zero;
			val3.offsetMax = Vector2.zero;
			Image val4 = OverlayLarge.AddComponent<Image>();
			val4.sprite = CircleMask;
			val4.preserveAspect = true;
			((Graphic)val4).raycastTarget = false;
			Mask val5 = OverlayLarge.AddComponent<Mask>();
			val5.showMaskGraphic = false;
			GameObject val6 = new GameObject("RawImageLarge");
			RectTransform val7 = val6.AddComponent<RectTransform>();
			((Transform)val7).SetParent((Transform)(object)val3, false);
			val7.anchorMin = Vector2.zero;
			val7.anchorMax = Vector2.one;
			val7.offsetMin = Vector2.zero;
			val7.offsetMax = Vector2.zero;
			RawImage val8 = val6.AddComponent<RawImage>();
			val8.texture = (Texture)(object)OverlayTex;
			((Graphic)val8).material = null;
			((Graphic)val8).raycastTarget = false;
			((MaskableGraphic)val8).maskable = true;
			Rect uvRect = val8.uvRect;
			Rect rect = val3.rect;
			float width = ((Rect)(ref rect)).width;
			rect = val3.rect;
			((Rect)(ref uvRect)).width = width / ((Rect)(ref rect)).height;
			((Rect)(ref uvRect)).height = 1f;
			((Rect)(ref uvRect)).center = new Vector2(0.5f, 0.5f);
			val8.uvRect = uvRect;
			OverlaySmall = new GameObject("CustomLayerSmall");
			RectTransform val9 = OverlaySmall.AddComponent<RectTransform>();
			((Transform)val9).SetParent(((Component)Minimap.instance.m_mapImageSmall).transform, false);
			((Transform)val9).SetAsFirstSibling();
			val9.anchorMin = Vector2.zero;
			val9.anchorMax = Vector2.one;
			RawImage val10 = OverlaySmall.AddComponent<RawImage>();
			val10.texture = (Texture)(object)OverlayTex;
			((Graphic)val10).material = null;
			((Graphic)val10).raycastTarget = false;
			stopwatch.Stop();
			Logger.LogDebug($"Setup took {stopwatch.ElapsedMilliseconds}ms time");
		}

		private void SetupGUI()
		{
			GameObject prefab = PrefabManager.Instance.GetPrefab("MinimapOverlayPanel");
			GameObject val = Object.Instantiate<GameObject>(prefab, Minimap.instance.m_mapLarge.transform, false);
			val.SetActive(false);
			OverlayPanel = val.GetComponent<MinimapOverlayPanel>();
			GUIManager.Instance.ApplyButtonStyle(OverlayPanel.Button);
			GUIManager.Instance.ApplyToogleStyle(OverlayPanel.BaseToggle);
			GUIManager.Instance.ApplyTextStyle(OverlayPanel.BaseModText);
		}

		private void AddOverlayToGUI(MapOverlay ovl)
		{
			Toggle val = OverlayPanel?.AddOverlayToggle(ovl.SourceMod.Name, ovl.Name);
			if (val != null)
			{
				val.SetIsOnWithoutNotify(ovl.Enabled);
			}
			((UnityEvent<bool>)(object)val?.onValueChanged).AddListener((UnityAction<bool>)delegate(bool active)
			{
				ovl.Enabled = active;
			});
			ovl.Toggle = val;
			MinimapOverlayPanel overlayPanel = OverlayPanel;
			if (overlayPanel != null)
			{
				((Component)overlayPanel).gameObject.SetActive(true);
			}
		}

		private void AddDrawingToGUI(MapDrawing ovl)
		{
			Toggle val = OverlayPanel?.AddOverlayToggle(ovl.SourceMod.Name, ovl.Name);
			if (val != null)
			{
				val.SetIsOnWithoutNotify(ovl.Enabled);
			}
			((UnityEvent<bool>)(object)val?.onValueChanged).AddListener((UnityAction<bool>)delegate(bool active)
			{
				ovl.Enabled = active;
			});
			ovl.Toggle = val;
			MinimapOverlayPanel overlayPanel = OverlayPanel;
			if (overlayPanel != null)
			{
				((Component)overlayPanel).gameObject.SetActive(true);
			}
		}

		private void Minimap_CenterMap(Minimap self, Vector3 centerpoint)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)OverlayLarge))
			{
				float num = default(float);
				float num2 = default(float);
				self.WorldToMapPoint(centerpoint, ref num, ref num2);
				Transform transform = OverlayLarge.transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				Rect rect = val.rect;
				float width = ((Rect)(ref rect)).width;
				rect = val.rect;
				float num3 = width / ((Rect)(ref rect)).height;
				float num4 = 1f / self.m_largeZoom;
				OverlayLarge.transform.localScale = Vector2.op_Implicit(new Vector2(num4, num4));
				int num5 = self.m_textureSize / 2;
				float num6 = centerpoint.x / self.m_pixelSize + (float)num5;
				float num7 = centerpoint.z / self.m_pixelSize + (float)num5;
				Vector2 anchoredPosition = new Vector2
				{
					x = 1024f - num6
				};
				ref float x = ref anchoredPosition.x;
				float num8 = x;
				rect = val.rect;
				x = num8 * (((Rect)(ref rect)).width / 2048f / num3);
				anchoredPosition.x *= num4;
				anchoredPosition.y = 1024f - num7;
				ref float y = ref anchoredPosition.y;
				float num9 = y;
				rect = val.rect;
				y = num9 * (((Rect)(ref rect)).height / 2048f);
				anchoredPosition.y *= num4;
				val.anchoredPosition = anchoredPosition;
				Rect uvRect = self.m_mapImageSmall.uvRect;
				((Rect)(ref uvRect)).width = ((Rect)(ref uvRect)).width + self.m_smallZoom / 2f;
				((Rect)(ref uvRect)).height = ((Rect)(ref uvRect)).height + self.m_smallZoom / 2f;
				((Rect)(ref uvRect)).center = new Vector2(num, num2);
				OverlaySmall.GetComponent<RawImage>().uvRect = uvRect;
			}
		}

		private void Minimap_OnDestroy()
		{
			foreach (MapOverlay value in Overlays.Values)
			{
				value.Destroy();
			}
			Instance.Overlays.Clear();
			foreach (MapDrawing value2 in Drawings.Values)
			{
				value2.Destroy();
			}
			Instance.Drawings.Clear();
		}

		[HarmonyPatch(typeof(Texture2D), "Apply", new Type[]
		{
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPostfix]
		private static void Texture2D_Apply(Texture2D __instance)
		{
			if ((Object)(object)__instance == (Object)(object)Minimap.instance?.m_fogTexture && !Instance.Drawings.Values.Any((MapDrawing x) => x.FogEnabled && x.Enabled) && Instance.Overlays.Values.Any((MapOverlay x) => !x.IgnoreFog))
			{
				Instance.SetFogDirty();
			}
			foreach (MapOverlay value in Instance.Overlays.Values)
			{
				value.SetTextureDirty(__instance);
			}
			foreach (MapDrawing value2 in Instance.Drawings.Values)
			{
				value2.SetTextureDirty(__instance);
			}
		}

		private void SetFogDirty()
		{
			foreach (MapOverlay item in Overlays.Values.Where((MapOverlay x) => !x.IgnoreFog))
			{
				item.Dirty = true;
			}
			foreach (MapDrawing item2 in Drawings.Values.Where((MapDrawing x) => x.FogEnabled))
			{
				item2.FogDirty = true;
			}
		}
	}
	internal class MockManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(ZoneSystem), "Start")]
			[HarmonyPostfix]
			private static void ZoneSystem_Start(ZoneSystem __instance)
			{
				FixQueuedMaterials();
			}
		}

		private static MockManager _instance;

		[Obsolete("Legacy ValheimLib mock prefix. Use JVLMockPrefix \"JVLmock_\" instead.")]
		public const string MockPrefix = "VLmock_";

		public const string JVLMockPrefix = "JVLmock_";

		public const string JVLMockSeparator = "__";

		internal GameObject MockPrefabContainer;

		private Dictionary<string, GameObject> mockedPrefabs = new Dictionary<string, GameObject>();

		private static HashSet<Material> fixedMaterials = new HashSet<Material>();

		private static HashSet<Material> queuedToFixMaterials = new HashSet<Material>();

		private static bool allVanillaObjectsAvailable;

		public static MockManager Instance => _instance ?? (_instance = new MockManager());

		private static MethodInfo Object_IsPersistent { get; } = AccessTools.Method(typeof(Object), "IsPersistent", (Type[])null, (Type[])null);

		private MockManager()
		{
			((IManager)this).Init();
		}

		void IManager.Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Main.LogInit("MockManager");
			MockPrefabContainer = new GameObject("MockPrefabs");
			MockPrefabContainer.transform.parent = Main.RootObject.transform;
			MockPrefabContainer.SetActive(false);
			Main.Harmony.PatchAll(typeof(Patches));
		}

		public GameObject CreateMockedGameObject(string prefabName)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			string text = "JVLmock_" + prefabName;
			if (mockedPrefabs.TryGetValue(text, out var value) && Object.op_Implicit((Object)(object)value))
			{
				return value;
			}
			GameObject val = new GameObject(text);
			val.transform.parent = MockPrefabContainer.transform;
			val.SetActive(false);
			mockedPrefabs[text] = val;
			return val;
		}

		public T CreateMockedPrefab<T>(string prefabName) where T : Component
		{
			GameObject val = CreateMockedGameObject(prefabName);
			string name = ((Object)val).name;
			T orAddComponent = val.GetOrAddComponent<T>();
			if (!Object.op_Implicit((Object)(object)orAddComponent))
			{
				Logger.LogWarning($"Could not create mock for prefab {prefabName} of type {typeof(T)}");
				return default(T);
			}
			((Object)(object)orAddComponent).name = name;
			return orAddComponent;
		}

		public static T GetRealPrefabFromMock<T>(Object unityObject) where T : Object
		{
			return (T)(object)GetRealPrefabFromMock(unityObject, typeof(T));
		}

		public static Object GetRealPrefabFromMock(Object unityObject, Type mockObjectType)
		{
			if (!Object.op_Implicit(unityObject))
			{
				return null;
			}
			if (GUIUtils.IsHeadless && mockObjectType == typeof(Texture))
			{
				return null;
			}
			if (!IsMockName(GetCleanedName(mockObjectType, unityObject.name), out var assetName, out var childNames))
			{
				return null;
			}
			if (childNames.Count == 0 && TryGetAsset(mockObjectType, assetName, out var asset))
			{
				return asset;
			}
			GameObject val = PrefabManager.Cache.GetPrefab<GameObject>(assetName);
			if (!Object.op_Implicit((Object)(object)val))
			{
				if (childNames.Count > 0)
				{
					MockResolveFailure.MockResolveFailures.Add(new MockResolveFailure("GameObject with name '" + assetName + "' was not found.", assetName, childNames, mockObjectType));
				}
				else
				{
					MockResolveFailure.MockResolveFailures.Add(new MockResolveFailure("", assetName, "", mockObjectType));
				}
				return null;
			}
			if (childNames.Count > 0)
			{
				Transform val2 = val.FindDeepChild(childNames, (IterativeSearchType)1);
				if (!Object.op_Implicit((Object)(object)val2) || ((Object)val2).name != childNames.Last())
				{
					MockResolveFailure.MockResolveFailures.Add(new MockResolveFailure("Child '" + childNames.Last() + "' not found with the specified path.", assetName, childNames, mockObjectType));
					return null;
				}
				val = ((Component)val2).gameObject;
			}
			if (PrefabManager.TryFindAssetInSelfOrChildComponents(val, mockObjectType, out asset))
			{
				return asset;
			}
			if (childNames.Count > 0)
			{
				string text = Utils.GetPath(val.transform).TrimStart(new char[1] { '/' });
				MockResolveFailure.MockResolveFailures.Add(new MockResolveFailure(mockObjectType.Name + " not found at child '" + text + "'.", assetName, childNames, mockObjectType));
			}
			else
			{
				MockResolveFailure.MockResolveFailures.Add(new MockResolveFailure(mockObjectType.Name + " not found at prefab '" + assetName + "'.", assetName, "", mockObjectType));
			}
			return null;
		}

		private static bool TryGetAsset(Type mockObjectType, string assetName, out Object asset)
		{
			asset = PrefabManager.Cache.GetPrefab(mockObjectType, assetName);
			return Object.op_Implicit(asset);
		}

		internal static void FixReferences(object objectToFix, int depth)
		{
			if (depth == 5 || objectToFix == null)
			{
				return;
			}
			Type type = objectToFix.GetType();
			ClassMember classMember = ClassMember.GetClassMember(type);
			foreach (MemberBase member in classMember.Members)
			{
				FixMemberReferences(member, objectToFix, depth + 1);
			}
		}

		internal static void ReplaceMockGameObject(Transform child, GameObject realPrefab, GameObject parent)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (IsPersistent(parent))
			{
				Logger.LogWarning("Cannot replace mock child " + ((Object)child).name + " in persistent prefab " + ((Object)parent).name + ". Clone the prefab before replacing mocks, i.e. with PrefabManager.Instance.CreateClonedPrefab or ZoneManager.Instance.CreateLocationContainer for locations");
			}
			else
			{
				GameObject val = Object.Instantiate<GameObject>(realPrefab, parent.transform);
				((Object)val).name = ((Object)realPrefab).name;
				val.SetActive(((Component)child).gameObject.activeSelf);
				val.transform.position = ((Component)child).gameObject.transform.position;
				val.transform.rotation = ((Component)child).gameObject.transform.rotation;
				val.transform.localScale = ((Component)child).gameObject.transform.localScale;
				int siblingIndex = child.GetSiblingIndex();
				Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
				val.transform.SetSiblingIndex(siblingIndex);
			}
		}

		private static bool IsPersistent(GameObject parent)
		{
			return (bool)Object_IsPersistent.Invoke(null, new object[1] { parent });
		}

		private static bool IsMockName(string name, out string assetName, out List<string> childNames)
		{
			name = name.Trim();
			if (name.StartsWith("JVLmock_", StringComparison.Ordinal))
			{
				string text = name.Substring("JVLmock_".Length);
				string[] array = text.Split(new string[1] { "__" }, StringSplitOptions.RemoveEmptyEntries);
				assetName = array[0];
				childNames = (from splitName in array.Skip(1)
					select splitName.Trim()).ToList();
				return true;
			}
			if (name.StartsWith("VLmock_", StringComparison.Ordinal))
			{
				assetName = name.Substring("VLmock_".Length);
				childNames = new List<string>();
				return true;
			}
			assetName = name;
			childNames = new List<string>();
			return false;
		}

		private static string GetCleanedName(Type objectType, string name)
		{
			if (objectType == typeof(Material))
			{
				return name.RemoveSuffix("(Instance)");
			}
			if (objectType == typeof(Mesh))
			{
				return name.RemoveSuffix("Instance");
			}
			return name.Trim();
		}

		private static void FixMemberReferences(MemberBase member, object objectToFix, int depth)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			if (member.MemberType == typeof(DropTable))
			{
				FixDropTable(member, objectToFix);
			}
			else if (member.IsUnityObject && member.HasGetMethod && member.HasSetMethod)
			{
				Object val = (Object)member.GetValue(objectToFix);
				Object realPrefabFromMock = GetRealPrefabFromMock(val, member.MemberType);
				if (Object.op_Implicit(realPrefabFromMock))
				{
					member.SetValue(objectToFix, realPrefabFromMock);
					return;
				}
				Material val2 = (Material)(object)((val is Material) ? val : null);
				if (val2 != null)
				{
					TryFixMaterial(val2);
				}
			}
			else if (member.IsEnumeratedClass && member.IsEnumerableOfUnityObjects && member.HasSetMethod)
			{
				bool isArray = member.MemberType.IsArray;
				bool flag = member.MemberType.IsGenericType && member.MemberType.GetGenericTypeDefinition() == typeof(List<>);
				bool flag2 = member.MemberType.IsGenericType && member.MemberType.GetGenericTypeDefinition() == typeof(HashSet<>);
				bool flag3 = member.MemberType.IsGenericType && member.MemberType.GetGenericTypeDefinition() == typeof(Dictionary<, >);
				if (!(isArray || flag || flag2))
				{
					if (!flag3 || !(member.EnumeratedType == typeof(ParticleSystem)))
					{
						Logger.LogWarning($"Not fixing potential mock references for field {member.MemberType.Name} : {member.MemberType} is not supported.");
					}
					return;
				}
				IEnumerable<Object> enumerable = (IEnumerable<Object>)member.GetValue(objectToFix);
				if (enumerable == null)
				{
					return;
				}
				List<Object> list = new List<Object>();
				bool flag4 = false;
				foreach (Object item in enumerable)
				{
					Object realPrefabFromMock2 = GetRealPrefabFromMock(item, member.EnumeratedType);
					list.Add(Object.op_Implicit(realPrefabFromMock2) ? realPrefabFromMock2 : item);
					flag4 = flag4 || Object.op_Implicit(realPrefabFromMock2);
					if (!Object.op_Implicit(realPrefabFromMock2))
					{
						Material val3 = (Material)(object)((item is Material) ? item : null);
						if (val3 != null)
						{
							TryFixMaterial(val3);
						}
					}
				}
				if (list.Count > 0 && flag4)
				{
					MethodInfo enumerableCast = ReflectionHelper.Cache.EnumerableCast;
					MethodInfo methodInfo = enumerableCast.MakeGenericMethod(member.EnumeratedType);
					object obj = methodInfo.Invoke(null, new object[1] { list });
					if (isArray)
					{
						MethodInfo enumerableToArray = ReflectionHelper.Cache.EnumerableToArray;
						MethodInfo methodInfo2 = enumerableToArray.MakeGenericMethod(member.EnumeratedType);
						object value = methodInfo2.Invoke(null, new object[1] { obj });
						member.SetValue(objectToFix, value);
					}
					else if (flag)
					{
						MethodInfo enumerableToList = ReflectionHelper.Cache.EnumerableToList;
						MethodInfo methodInfo3 = enumerableToList.MakeGenericMethod(member.EnumeratedType);
						object value2 = methodInfo3.Invoke(null, new object[1] { obj });
						member.SetValue(objectToFix, value2);
					}
					else if (flag2)
					{
						Type type = typeof(HashSet<>).MakeGenericType(member.EnumeratedType);
						object value3 = Activator.CreateInstance(type, obj);
						member.SetValue(objectToFix, value3);
					}
				}
			}
			else
			{
				if (member.IsEnumeratedClass)
				{
					if (member.MemberType.IsGenericType && member.MemberType.GetGenericTypeDefinition() == typeof(Dictionary<, >))
					{
						Logger.LogWarning("Not fixing potential mock references for field " + member.MemberType.Name + " : Dictionary is not supported.");
						return;
					}
					IEnumerable<object> enumerable2 = (IEnumerable<object>)member.GetValue(objectToFix);
					if (enumerable2 == null)
					{
						return;
					}
					{
						foreach (object item2 in enumerable2)
						{
							FixReferences(item2, depth);
						}
						return;
					}
				}
				if (member.IsClass && member.HasGetMethod)
				{
					FixReferences(member.GetValue(objectToFix), depth);
				}
			}
		}

		private static void FixDropTable(MemberBase member, object objectToFix)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			List<DropData> drops = ((DropTable)member.GetValue(objectToFix)).m_drops;
			for (int i = 0; i < drops.Count; i++)
			{
				DropData val = drops[i];
				GameObject realPrefabFromMock = MockManager.GetRealPrefabFromMock<GameObject>((Object)(object)val.m_item);
				if (Object.op_Implicit((Object)(object)realPrefabFromMock))
				{
					val.m_item = realPrefabFromMock;
				}
				drops[i] = val;
			}
		}

		private static void TryFixMaterial(Material material)
		{
			if (!GUIUtils.IsHeadless && Object.op_Implicit((Object)(object)material) && !fixedMaterials.Contains(material) && !queuedToFixMaterials.Contains(material))
			{
				FixMaterial(material);
			}
		}

		private static void FixQueuedMaterials()
		{
			MockResolveFailure.MockResolveFailures.Clear();
			PrefabManager.Cache.Clear<Texture>();
			allVanillaObjectsAvailable = true;
			foreach (Material item in new HashSet<Material>(queuedToFixMaterials))
			{
				queuedToFixMaterials.Remove(item);
				FixMaterial(item);
			}
			MockResolveFailure.PrintMockResolveFailures(string.Empty);
		}

		private static void FixMaterial(Material material)
		{
			if (Object.op_Implicit((Object)(object)material) && !fixedMaterials.Contains(material))
			{
				bool flag = FixTextures(material);
				bool flag2 = true;
				if (!GUIUtils.IsHeadless)
				{
					flag2 = FixShader(material);
				}
				if (flag && flag2)
				{
					fixedMaterials.Add(material);
				}
				else
				{
					queuedToFixMaterials.Add(material);
				}
			}
		}

		private static bool FixTextures(Material material)
		{
			bool result = true;
			int count = MockResolveFailure.MockResolveFailures.Count;
			int[] texturePropertyNameIDs = material.GetTexturePropertyNameIDs();
			foreach (int num in texturePropertyNameIDs)
			{
				Texture texture = material.GetTexture(num);
				if (Object.op_Implicit((Object)(object)texture))
				{
					Texture realPrefabFromMock = MockManager.GetRealPrefabFromMock<Texture>((Object)(object)texture);
					if (MockResolveFailure.MockResolveFailures.Count > count)
					{
						result = false;
						count = MockResolveFailure.MockResolveFailures.Count;
					}
					else if (Object.op_Implicit((Object)(object)realPrefabFromMock))
					{
						material.SetTexture(num, realPrefabFromMock);
					}
				}
			}
			return result;
		}

		private static bool FixShader(Material material)
		{
			Shader shader = material.shader;
			if (!Object.op_Implicit((Object)(object)shader) || !IsMockName(((Object)shader).name, out var assetName, out var _))
			{
				return true;
			}
			Shader prefab = PrefabManager.Cache.GetPrefab<Shader>(assetName);
			if (Object.op_Implicit((Object)(object)prefab))
			{
				material.shader = prefab;
				return true;
			}
			if (allVanillaObjectsAvailable)
			{
				Logger.LogWarning("Could not find shader " + ((Object)shader).name);
			}
			return false;
		}
	}
	public class NetworkManager : IManager
	{
		public delegate IEnumerator CoroutineHandler(long sender, ZPackage package);

		private static class Patches
		{
			[HarmonyPatch(typeof(Game), "Start")]
			[HarmonyPostfix]
			private static void Game_Start()
			{
				Instance.Game_Start();
			}
		}

		private static NetworkManager _instance;

		internal readonly List<CustomRPC> RPCs = new List<CustomRPC>();

		public static NetworkManager Instance => _instance ?? (_instance = new NetworkManager());

		private NetworkManager()
		{
		}

		static NetworkManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("NetworkManager");
			Main.Harmony.PatchAll(typeof(Patches));
		}

		public CustomRPC AddRPC(string name, CoroutineHandler serverReceive, CoroutineHandler clientReceive)
		{
			return AddRPC(BepInExUtils.GetSourceModMetadata(), name, serverReceive, clientReceive);
		}

		internal CustomRPC AddRPC(BepInPlugin sourceMod, string name, CoroutineHandler serverReceive, CoroutineHandler clientReceive)
		{
			CustomRPC customRPC = RPCs.FirstOrDefault((CustomRPC x) => x.SourceMod == sourceMod && x.Name == name);
			if (customRPC != null)
			{
				return customRPC;
			}
			customRPC = new CustomRPC(sourceMod, name, serverReceive, clientReceive);
			RPCs.Add(customRPC);
			return customRPC;
		}

		private void Game_Start()
		{
			if (!RPCs.Any())
			{
				return;
			}
			Logger.LogInfo($"Registering {RPCs.Count} custom RPCs");
			foreach (CustomRPC rPC in RPCs)
			{
				ZRoutedRpc.instance.Register<ZPackage>(rPC.ID, (Action<long, ZPackage>)rPC.ReceivePackage);
			}
		}
	}
	public class PieceManager : IManager
	{
		[Obsolete("No longer used")]
		public static class PieceCategorySettings
		{
			[Obsolete("This setting is no longer used")]
			public static float HeaderWidth { get; set; } = 700f;

			[Obsolete("This setting is no longer used")]
			public static float MinTabSize { get; set; } = 140f;

			[Obsolete("This setting is no longer used")]
			public static float TabSizePerCharacter { get; set; } = 11f;

			[Obsolete("This setting is no longer used")]
			public static float TabMargin { get; set; } = 50f;
		}

		private static class Patches
		{
			[HarmonyPatch(typeof(Player), "SetPlaceMode")]
			[HarmonyPostfix]
			[HarmonyPriority(200)]
			public static void Player_SetPlaceMode()
			{
				Instance.RefreshCategories();
			}

			[HarmonyPatch(typeof(Hud), "Awake")]
			[HarmonyPostfix]
			[HarmonyPriority(200)]
			private static void Hud_Awake()
			{
				Instance.RefreshCategories();
			}

			[HarmonyPatch(typeof(Hud), "UpdateBuild")]
			[HarmonyPrefix]
			[HarmonyPriority(200)]
			private static void Hud_UpdateBuild()
			{
				Instance.RefreshCategoriesIfNeeded();
			}

			[HarmonyPatch(typeof(Hud), "LateUpdate")]
			[HarmonyPostfix]
			[HarmonyPriority(200)]
			private static void Hud_LateUpdate()
			{
				Instance.RefreshCategoriesIfNeeded();
			}

			[HarmonyPatch(typeof(ObjectDB), "Awake")]
			[HarmonyPostfix]
			[HarmonyPriority(200)]
			private static void RegisterCustomData(ObjectDB __instance)
			{
				Instance.RegisterCustomData(__instance);
			}

			[HarmonyPatch(typeof(ObjectDB), "Awake")]
			[HarmonyPostfix]
			[HarmonyPriority(0)]
			private static void InvokeOnPiecesRegistered(ObjectDB __instance)
			{
				Instance.InvokeOnPiecesRegistered(__instance);
			}

			[HarmonyPatch(typeof(Player), "OnSpawned")]
			[HarmonyPostfix]
			private static void ReloadKnownRecipes(Player __instance)
			{
				Instance.ReloadKnownRecipes(__instance);
			}

			[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
			[HarmonyPrefix]
			public static void PieceTable_UpdateAvailable_Prefix(PieceTable __instance)
			{
				ExpandAvailablePieces(__instance);
			}

			[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
			[HarmonyPostfix]
			public static void PieceTable_UpdateAvailable_Postfix(PieceTable __instance)
			{
				AdjustPieceTableArray(__instance);
				ReorderAllCategoryPieces(__instance);
			}

			[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> UpdateAvailable_Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				return TranspileMaxCategory(instructions, 0);
			}

			[HarmonyPatch(typeof(Enum), "GetValues")]
			[HarmonyPostfix]
			private static void EnumGetValuesPatch(Type enumType, ref Array __result)
			{
				Instance.EnumGetValuesPatch(enumType, ref __result);
			}

			[HarmonyPatch(typeof(Enum), "GetNames")]
			[HarmonyPostfix]
			private static void EnumGetNamesPatch(Type enumType, ref string[] __result)
			{
				Instance.EnumGetNamesPatch(enumType, ref __result);
			}
		}

		private static PieceManager _instance;

		internal readonly Dictionary<string, CustomPiece> Pieces = new Dictionary<string, CustomPiece>();

		internal readonly List<CustomPieceTable> PieceTables = new List<CustomPieceTable>();

		private readonly Dictionary<string, PieceTable> PieceTableMap = new Dictionary<string, PieceTable>();

		private readonly Dictionary<string, string> PieceTableNameMap = new Dictionary<string, string>();

		private readonly Dictionary<string, PieceCategory> PieceCategories = new Dictionary<string, PieceCategory>();

		private readonly Dictionary<string, PieceCategory> OtherPieceCategories = new Dictionary<string, PieceCategory>();

		private readonly Dictionary<PieceCategory, string> vanillaLabels = new Dictionary<PieceCategory, string>();

		private bool categoryRefreshNeeded = true;

		private static string hiddenCategoryMagic;

		public static PieceManager Instance => _instance ?? (_instance = new PieceManager());

		public static event Action OnPiecesRegistered;

		private PieceManager()
		{
		}

		static PieceManager()
		{
			hiddenCategoryMagic = "(HiddenCategory)";
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("PieceManager");
			Main.Harmony.PatchAll(typeof(Patches));
			PrefabManager.Instance.Activate();
			if (Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				LoadPieceTables();
			}
		}

		public bool AddPieceTable(CustomPieceTable customPieceTable)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (!customPieceTable.IsValid())
			{
				Logger.LogWarning(customPieceTable.SourceMod, $"Custom piece {customPieceTable} is not valid");
				return false;
			}
			if (PieceTables.Contains(customPieceTable))
			{
				Logger.LogWarning(customPieceTable.SourceMod, $"Piece table {customPieceTable} already added");
				return false;
			}
			if (!PrefabManager.Instance.AddPrefab(customPieceTable.PieceTablePrefab, customPieceTable.SourceMod))
			{
				return false;
			}
			string[] categories = customPieceTable.Categories;
			foreach (string name in categories)
			{
				AddPieceCategory(name);
			}
			PieceTables.Add(customPieceTable);
			PieceTableMap.Add(customPieceTable.ToString(), customPieceTable.PieceTable);
			return true;
		}

		[Obsolete("Use CustomPieceTable instead")]
		public void AddPieceTable(GameObject prefab)
		{
			AddPieceTable(new CustomPieceTable(prefab));
		}

		[Obsolete("Use CustomPieceTable instead")]
		public void AddPieceTable(string name)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.AddComponent<PieceTable>();
			AddPieceTable(new CustomPieceTable(val, new PieceTableConfig()));
		}

		public PieceTable GetPieceTable(string name)
		{
			if (PieceTableMap.ContainsKey(name))
			{
				return PieceTableMap[name];
			}
			if (PieceTableNameMap.ContainsKey(name))
			{
				return PieceTableMap[PieceTableNameMap[name]];
			}
			return null;
		}

		public List<PieceTable> GetPieceTables()
		{
			return PieceTableMap.Values.ToList();
		}

		[Obsolete("Use AddPieceCategory(string name) instead")]
		public PieceCategory AddPieceCategory(string table, string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return AddPieceCategory(name);
		}

		public PieceCategory AddPieceCategory(string name)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			bool isNew;
			PieceCategory orCreatePieceCategory = GetOrCreatePieceCategory(name, out isNew);
			if (isNew)
			{
				CreateCategoryTabs();
			}
			categoryRefreshNeeded = true;
			return orCreatePieceCategory;
		}

		public PieceCategory? GetPieceCategory(string name)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<PieceCategory>(name, ignoreCase: true, out PieceCategory result))
			{
				return result;
			}
			if (PieceCategories.TryGetValue(name, out result))
			{
				return result;
			}
			if (OtherPieceCategories.TryGetValue(name, out result))
			{
				return result;
			}
			return null;
		}

		[Obsolete("Use RemovePieceCategory(string name) instead")]
		public void RemovePieceCategory(string table, string name)
		{
			RemovePieceCategory(name);
		}

		public void RemovePieceCategory(string name)
		{
			categoryRefreshNeeded = true;
		}

		[Obsolete("Use GetPieceCategoriesMap to get a complete map of all categories, not only Jötunn ones")]
		public List<string> GetPieceCategories()
		{
			return PieceCategories.Keys.ToList();
		}

		public Dictionary<PieceCategory, string> GetPieceCategoriesMap()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Array values = Enum.GetValues(typeof(PieceCategory));
			string[] names = Enum.GetNames(typeof(PieceCategory));
			Dictionary<PieceCategory, string> dictionary = new Dictionary<PieceCategory, string>();
			for (int i = 0; i < values.Length; i++)
			{
				dictionary[(PieceCategory)values.GetValue(i)] = names[i];
			}
			return dictionary;
		}

		public bool AddPiece(CustomPiece customPiece)
		{
			if (!customPiece.IsValid())
			{
				Logger.LogWarning(customPiece.SourceMod, $"Custom piece {customPiece} is not valid");
				return false;
			}
			if (Pieces.ContainsKey(((Object)customPiece.PiecePrefab).name))
			{
				Logger.LogWarning(customPiece.SourceMod, $"Custom piece {customPiece} already added");
				return false;
			}
			if (!PrefabManager.Instance.AddPrefab(customPiece.PiecePrefab, customPiece.SourceMod))
			{
				return false;
			}
			if (customPiece.PiecePrefab.layer == 0)
			{
				customPiece.PiecePrefab.layer = LayerMask.NameToLayer("piece");
			}
			Pieces.Add(((Object)customPiece.PiecePrefab).name, customPiece);
			return true;
		}

		public CustomPiece GetPiece(string pieceName)
		{
			if (!Pieces.TryGetValue(pieceName, out var value))
			{
				return null;
			}
			return value;
		}

		public void RemovePiece(string pieceName)
		{
			CustomPiece piece = GetPiece(pieceName);
			if (piece == null)
			{
				Logger.LogWarning("Could not remove piece " + pieceName + ": Not found");
			}
			else
			{
				RemovePiece(piece);
			}
		}

		public void RemovePiece(CustomPiece piece)
		{
			string name = ((Object)piece.PiecePrefab).name;
			if (!Pieces.ContainsKey(name))
			{
				Logger.LogWarning(piece.SourceMod, $"Could not remove piece {piece}: Not found");
				return;
			}
			Pieces.Remove(name);
			if (Object.op_Implicit((Object)(object)piece.PiecePrefab) && Object.op_Implicit((Object)(object)PrefabManager.Instance.GetPrefab(((Object)piece.PiecePrefab).name)))
			{
				PrefabManager.Instance.RemovePrefab(((Object)piece.PiecePrefab).name);
			}
		}

		private void LoadPieceTables()
		{
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				PieceTable val = item.GetComponent<ItemDrop>()?.m_itemData.m_shared.m_buildPieces;
				if ((Object)(object)val != (Object)null)
				{
					PieceTableMap[((Object)val).name] = val;
					PieceTableNameMap[((Object)item).name] = ((Object)val).name;
				}
			}
		}

		private void RegisterInPieceTables()
		{
			if (!Pieces.Any())
			{
				return;
			}
			Logger.LogInfo($"Adding {Pieces.Count} custom pieces to the PieceTables");
			List<CustomPiece> list = new List<CustomPiece>();
			foreach (KeyValuePair<string, CustomPiece> piece in Pieces)
			{
				CustomPiece value = piece.Value;
				try
				{
					RegisterCustomPiece(value);
				}
				catch (Exception arg)
				{
					Logger.LogWarning(value?.SourceMod, $"Error caught while adding piece {value}: {arg}");
					list.Add(value);
				}
			}
			foreach (CustomPiece item in list)
			{
				if (Object.op_Implicit((Object)(object)item.PiecePrefab))
				{
					PrefabManager.Instance.DestroyPrefab(((Object)item.PiecePrefab).name);
				}
				RemovePiece(item);
			}
		}

		private void RegisterCustomPiece(CustomPiece customPiece)
		{
			if (customPiece.FixReference || customPiece.FixConfig)
			{
				customPiece.PiecePrefab.FixReferences(customPiece.FixReference);
				customPiece.FixReference = false;
				customPiece.FixConfig = false;
			}
			StationExtension component = customPiece.PiecePrefab.GetComponent<StationExtension>();
			if ((Object)(object)component != (Object)null && !Object.op_Implicit((Object)(object)component.m_connectionPrefab))
			{
				component.m_connectionPrefab = PrefabManager.Cache.GetPrefab<GameObject>("vfx_ExtensionConnection");
			}
			RegisterPieceInPieceTable(customPiece.PiecePrefab, customPiece.PieceTable, null, customPiece.SourceMod);
		}

		public void RegisterPieceInPieceTable(GameObject prefab, string pieceTable, string category = null)
		{
			RegisterPieceInPieceTable(prefab, pieceTable, category, BepInExUtils.GetSourceModMetadata());
		}

		private void RegisterPieceInPieceTable(GameObject prefab, string pieceTable, string category, BepInPlugin sourceMod)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			Piece component = prefab.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null)
			{
				throw new Exception("Prefab " + ((Object)prefab).name + " has no Piece component attached");
			}
			PieceTable pieceTable2 = GetPieceTable(pieceTable);
			if ((Object)(object)pieceTable2 == (Object)null)
			{
				throw new Exception("Could not find PieceTable " + pieceTable);
			}
			if (pieceTable2.m_pieces.Contains(prefab))
			{
				Logger.LogDebug("Already added piece " + ((Object)prefab).name);
				return;
			}
			string name = ((Object)prefab).name;
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (!PrefabManager.Instance.Prefabs.ContainsKey(name))
			{
				PrefabManager.Instance.AddPrefab(prefab, sourceMod);
			}
			if ((Object)(object)ZNetScene.instance != (Object)null && !ZNetScene.instance.m_namedPrefabs.ContainsKey(stableHashCode))
			{
				PrefabManager.Instance.RegisterToZNetScene(prefab);
			}
			if (!string.IsNullOrEmpty(category))
			{
				component.m_category = AddPieceCategory(category);
			}
			pieceTable2.m_pieces.Add(prefab);
			Logger.LogDebug("Added piece " + ((Object)prefab).name + " | Token: " + component.TokenName());
		}

		private void RegisterCustomData(ObjectDB self)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name == "main")
			{
				LoadPieceTables();
				RegisterInPieceTables();
			}
		}

		private void InvokeOnPiecesRegistered(ObjectDB self)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name == "main")
			{
				PieceManager.OnPiecesRegistered?.SafeInvoke();
			}
		}

		private void ReloadKnownRecipes(Player self)
		{
			if (!Pieces.Any())
			{
				return;
			}
			try
			{
				self.UpdateKnownRecipesList();
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"Exception caught while reloading player recipes: {arg}");
			}
		}

		private static int MaxCategory()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between I4 and Unknown
			int num = Enum.GetValues(typeof(PieceCategory)).Length - 1;
			if (num >= (int)PieceUtils.VanillaAllPieceCategory)
			{
				return num + 1;
			}
			return num;
		}

		private static IEnumerable<CodeInstruction> TranspileMaxCategory(IEnumerable<CodeInstruction> instructions, int maxOffset)
		{
			int number = PieceUtils.VanillaMaxPieceCategory + maxOffset;
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Call && instruction.operand is MethodInfo methodInfo && methodInfo.Name.Contains("MaxCategory"))
				{
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(PieceManager), "MaxCategory", (Type[])null, (Type[])null));
				}
				else if (CodeInstructionExtensions.LoadsConstant(instruction, (long)number))
				{
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(PieceManager), "MaxCategory", (Type[])null, (Type[])null));
					if (maxOffset != 0)
					{
						yield return new CodeInstruction(OpCodes.Ldc_I4, (object)maxOffset);
						yield return new CodeInstruction(OpCodes.Add, (object)null);
					}
				}
				else
				{
					yield return instruction;
				}
			}
		}

		private void EnumGetValuesPatch(Type enumType, ref Array __result)
		{
			if (!(enumType != typeof(PieceCategory)) && PieceCategories.Count != 0)
			{
				PieceCategory[] array = (PieceCategory[])(object)new PieceCategory[__result.Length + PieceCategories.Count];
				__result.CopyTo(array, 0);
				PieceCategories.Values.CopyTo(array, __result.Length);
				__result = array;
			}
		}

		private void EnumGetNamesPatch(Type enumType, ref string[] __result)
		{
			if (!(enumType != typeof(PieceCategory)) && PieceCategories.Count != 0)
			{
				__result = CollectionExtensions.AddRangeToArray<string>(__result, PieceCategories.Keys.ToArray());
			}
		}

		private static void ExpandAvailablePieces(PieceTable __instance)
		{
			if (__instance.m_availablePieces.Count > 0)
			{
				int num = MaxCategory() - __instance.m_availablePieces.Count;
				for (int i = 0; i < num; i++)
				{
					__instance.m_availablePieces.Add(new List<Piece>());
				}
			}
		}

		private static void AdjustPieceTableArray(PieceTable pieceTable)
		{
			Array.Resize(ref pieceTable.m_selectedPiece, pieceTable.m_availablePieces.Count);
			Array.Resize(ref pieceTable.m_lastSelectedPiece, pieceTable.m_availablePieces.Count);
		}

		private static void ReorderAllCategoryPieces(PieceTable pieceTable)
		{
			List<Piece> list = pieceTable.m_pieces.Select((GameObject i) => i.GetComponent<Piece>()).ToList();
			List<Piece> list2 = list.FindAll((Piece i) => Object.op_Implicit((Object)(object)i) && i.m_category == PieceUtils.VanillaAllPieceCategory);
			foreach (List<Piece> availablePiece in pieceTable.m_availablePieces)
			{
				int num = 0;
				foreach (Piece item in list2)
				{
					availablePiece.Remove(item);
					availablePiece.Insert(Mathf.Min(num, pieceTable.m_availablePieces.Count), item);
					num++;
				}
			}
		}

		private static void SetTabActive(GameObject tab, string tabName, bool active)
		{
			tab.SetActive(active);
			if (active)
			{
				((Object)tab).name = tabName.Replace(hiddenCategoryMagic, "");
			}
			else
			{
				((Object)tab).name = tabName + hiddenCategoryMagic;
			}
		}

		private static HashSet<PieceCategory> CategoriesInPieceTable(PieceTable pieceTable)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			HashSet<PieceCategory> hashSet = new HashSet<PieceCategory>();
			foreach (GameObject piece in pieceTable.m_pieces)
			{
				hashSet.Add(piece.GetComponent<Piece>().m_category);
			}
			return hashSet;
		}

		private void CreateCategoryTabs()
		{
			if (Object.op_Implicit((Object)(object)Hud.instance))
			{
				int num = MaxCategory();
				for (int i = Hud.instance.m_pieceCategoryTabs.Length; i < num; i++)
				{
					GameObject val = CreateCategoryTab();
					Hud.instance.m_pieceCategoryTabs = CollectionExtensions.AddItem<GameObject>((IEnumerable<GameObject>)Hud.instance.m_pieceCategoryTabs, val).ToArray();
				}
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
				{
					Player.m_localPlayer.UpdateAvailablePiecesList();
				}
			}
		}

		private string GetCategoryToken(string name)
		{
			char[] separator = " (){}[]+-!?/\\\\&%,.:-=<>\n".ToCharArray();
			string text = string.Join("_", name.ToLower().Split(separator));
			return "jotunn_cat_" + text;
		}

		private PieceCategory GetOrCreatePieceCategory(string name, out bool isNew)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			PieceCategory? pieceCategory = GetPieceCategory(name);
			if (pieceCategory.HasValue)
			{
				isNew = false;
				return pieceCategory.Value;
			}
			Dictionary<PieceCategory, string> pieceCategoriesMap = GetPieceCategoriesMap();
			PieceCategory key;
			foreach (KeyValuePair<PieceCategory, string> item in pieceCategoriesMap)
			{
				if (item.Value == name)
				{
					key = item.Key;
					OtherPieceCategories[name] = key;
					isNew = false;
					return key;
				}
			}
			key = (PieceCategory)(pieceCategoriesMap.Count - 1);
			if (key >= PieceUtils.VanillaAllPieceCategory)
			{
				key = (PieceCategory)(key + 1);
			}
			PieceCategories[name] = key;
			string token = GetCategoryToken(name);
			LocalizationManager.Instance.JotunnLocalization.AddTranslation(in token, name);
			isNew = true;
			return key;
		}

		private GameObject CreateCategoryTab()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Hud.instance.m_pieceCategoryTabs[0];
			GameObject val2 = Object.Instantiate<GameObject>(val, val.transform.parent);
			val2.SetActive(false);
			UIInputHandler orAddComponent = val2.GetOrAddComponent<UIInputHandler>();
			orAddComponent.m_onLeftDown = (Action<UIInputHandler>)Delegate.Combine(orAddComponent.m_onLeftDown, new Action<UIInputHandler>(Hud.instance.OnLeftClickCategory));
			TMP_Text[] componentsInChildren = val2.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val3 in componentsInChildren)
			{
				val3.rectTransform.offsetMin = new Vector2(3f, 1f);
				val3.rectTransform.offsetMax = new Vector2(-3f, -1f);
				val3.enableAutoSizing = true;
				val3.fontSizeMin = 10f;
				val3.fontSizeMax = 20f;
				val3.lineSpacing = 0.8f;
				val3.textWrappingMode = (TextWrappingModes)1;
				val3.overflowMode = (TextOverflowModes)3;
			}
			return val2;
		}

		private void RefreshCategoriesIfNeeded()
		{
			if (categoryRefreshNeeded)
			{
				categoryRefreshNeeded = false;
				RefreshCategories();
			}
		}

		private void RefreshCategories()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			CreateCategoryTabs();
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			PieceTable buildPieces = Player.m_localPlayer.m_buildPieces;
			if (Object.op_Implicit((Object)(object)buildPieces))
			{
				RectTransform val = (RectTransform)Hud.instance.m_pieceCategoryTabs[0].transform;
				RectTransform val2 = (RectTransform)Hud.instance.m_pieceCategoryRoot.transform;
				RectTransform val3 = (RectTransform)Hud.instance.m_pieceSelectionWindow.transform;
				HorizontalLayoutGroup val4 = default(HorizontalLayoutGroup);
				if (((Component)((Transform)val).parent).TryGetComponent<HorizontalLayoutGroup>(ref val4))
				{
					((Behaviour)val4).enabled = false;
				}
				Rect rect = val.rect;
				Vector2 size = ((Rect)(ref rect)).size;
				HashSet<PieceCategory> visibleCategories = CategoriesInPieceTable(buildPieces);
				UpdatePieceTableCategories(buildPieces, visibleCategories);
				rect = val2.rect;
				int num = Mathf.Max((int)(((Rect)(ref rect)).width / size.x), 1);
				int count = buildPieces.m_categories.Count;
				GridLayoutGroup val5 = default(GridLayoutGroup);
				if (((Component)((Transform)val).parent).TryGetComponent<GridLayoutGroup>(ref val5))
				{
					val5.constraintCount = num;
				}
				float num2 = (0f - size.x) * (float)num / 2f + size.x / 2f;
				float num3 = (size.y + 1f) * Mathf.Floor((float)(count - 1) / (float)num) + 5f;
				Vector2 val6 = default(Vector2);
				((Vector2)(ref val6))..ctor(num2, num3);
				int num4 = 0;
				for (int i = 0; i < buildPieces.m_categories.Count; i++)
				{
					GameObject val7 = Hud.instance.m_pieceCategoryTabs[i];
					RectTransform component = val7.GetComponent<RectTransform>();
					float num5 = size.x * (float)(num4 % num);
					float num6 = (0f - (size.y + 1f)) * (Mathf.Floor((float)num4 / (float)num) + 0.5f);
					component.anchoredPosition = val6 + new Vector2(num5, num6);
					component.anchorMin = new Vector2(0.5f, 1f);
					component.anchorMax = new Vector2(0.5f, 1f);
					num4++;
				}
				Transform obj = ((Transform)val3).Find("Bkg2");
				RectTransform val8 = (RectTransform)((obj != null) ? ((Component)obj).transform : null);
				if (Object.op_Implicit((Object)(object)val8))
				{
					float num7 = (size.y + 1f) * (float)Mathf.Max(0, Mathf.FloorToInt((float)(num4 - 1) / (float)num));
					val8.offsetMax = new Vector2(val8.offsetMax.x, num7);
				}
				else
				{
					Logger.LogWarning("Category Refresh: Could not find background image, skipping resize");
				}
				((Component)Hud.instance).GetComponentInParent<Localize>().RefreshLocalization();
			}
		}

		private void UpdatePieceTableCategories(PieceTable pieceTable, HashSet<PieceCategory> visibleCategories)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Invalid comparison between I4 and Unknown
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < (int)PieceUtils.VanillaMaxPieceCategory; i++)
			{
				PieceCategory val = (PieceCategory)i;
				if (visibleCategories.Contains(val) && !pieceTable.m_categories.Contains(val))
				{
					pieceTable.m_categories.Add(val);
					pieceTable.m_categoryLabels.Add(GetVanillaLabel(val));
				}
				if (!visibleCategories.Contains(val) && pieceTable.m_categories.Contains(val))
				{
					int index = pieceTable.m_categories.IndexOf(val);
					pieceTable.m_categories.RemoveAt(index);
					pieceTable.m_categoryLabels.RemoveAt(index);
				}
			}
			foreach (KeyValuePair<string, PieceCategory> pieceCategory in PieceCategories)
			{
				string key = pieceCategory.Key;
				PieceCategory value = pieceCategory.Value;
				if (visibleCategories.Contains(value) && !pieceTable.m_categories.Contains(value))
				{
					pieceTable.m_categories.Add(value);
					pieceTable.m_categoryLabels.Add("$" + GetCategoryToken(key));
				}
				if (!visibleCategories.Contains(value) && pieceTable.m_categories.Contains(value))
				{
					int index2 = pieceTable.m_categories.IndexOf(value);
					pieceTable.m_categories.RemoveAt(index2);
					pieceTable.m_categoryLabels.RemoveAt(index2);
				}
			}
		}

		private string GetVanillaLabel(PieceCategory category)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!vanillaLabels.ContainsKey(category))
			{
				SearchVanillaLabels();
			}
			if (!vanillaLabels.TryGetValue(category, out var value))
			{
				return string.Empty;
			}
			return value;
		}

		private void SearchVanillaLabels()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			PieceTable[] array = Resources.FindObjectsOfTypeAll<PieceTable>();
			foreach (PieceTable val in array)
			{
				for (int j = 0; j < val.m_categories.Count; j++)
				{
					PieceCategory key = val.m_categories[j];
					if (j < val.m_categoryLabels.Count && !vanillaLabels.ContainsKey(key) && !string.IsNullOrEmpty(val.m_categoryLabels[j]))
					{
						vanillaLabels[key] = val.m_categoryLabels[j];
					}
				}
			}
		}
	}
	public class PrefabManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(ZNetScene), "Awake")]
			[HarmonyPostfix]
			private static void RegisterAllToZNetScene()
			{
				Instance.RegisterAllToZNetScene();
			}

			[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
			[HarmonyPrefix]
			[HarmonyPriority(0)]
			private static void InvokeOnVanillaObjectsAvailable(ObjectDB other)
			{
				Instance.MenuObjectDB = other;
				Instance.InvokeOnVanillaObjectsAvailable();
			}

			[HarmonyPatch(typeof(ZNetScene), "Awake")]
			[HarmonyPostfix]
			[HarmonyPriority(0)]
			private static void InvokeOnPrefabsRegistered()
			{
				Instance.InvokeOnPrefabsRegistered();
			}

			[HarmonyPatch(typeof(ZoneSystem), "SetupLocations")]
			[HarmonyPrefix]
			[HarmonyPriority(600)]
			private static void ZoneSystem_ClearPrefabCache(ZoneSystem __instance)
			{
				Cache.Clear();
			}
		}

		public static class Cache
		{
			private static readonly Dictionary<Type, Dictionary<string, Object>> dictionaryCache = new Dictionary<Type, Dictionary<string, Object>>();

			public static Object GetPrefab(Type type, string name)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				if (AssetManager.Instance.IsReady())
				{
					SoftReference<Object> softReference = AssetManager.Instance.GetSoftReference(type, name);
					if (softReference.IsValid)
					{
						softReference.Load();
						if (Object.op_Implicit(softReference.Asset))
						{
							if (((object)softReference.Asset).GetType() == type)
							{
								return softReference.Asset;
							}
							Object asset = softReference.Asset;
							GameObject val = (GameObject)(object)((asset is GameObject) ? asset : null);
							if (val != null && TryFindAssetInSelfOrChildComponents(val, type, out var asset2))
							{
								return asset2;
							}
						}
					}
				}
				if (GetCachedMap(type).TryGetValue(name, out var value))
				{
					return value;
				}
				return null;
			}

			public static T GetPrefab<T>(string name) where T : Object
			{
				return (T)(object)GetPrefab(typeof(T), name);
			}

			public static Dictionary<string, Object> GetPrefabs(Type type)
			{
				return GetCachedMap(type);
			}

			private static Transform GetParent(Object obj)
			{
				GameObject val = (GameObject)(object)((obj is GameObject) ? obj : null);
				if (val == null)
				{
					return null;
				}
				return val.transform.parent;
			}

			private static Object FindBestAsset(IDictionary<string, Object> map, Object newObject, string name)
			{
				if (!map.TryGetValue(name, out var value))
				{
					return newObject;
				}
				if (name == "_NetScene")
				{
					GameObject val = (GameObject)(object)((value is GameObject) ? value : null);
					if (val != null)
					{
						GameObject val2 = (GameObject)(object)((newObject is GameObject) ? newObject : null);
						if (val2 != null && !val.activeInHierarchy && val2.activeInHierarchy)
						{
							return (Object)(object)val2;
						}
					}
				}
				Material val3 = (Material)(object)((value is Material) ? value : null);
				if (val3 != null)
				{
					Material val4 = (Material)(object)((newObject is Material) ? newObject : null);
					if (val4 != null && FindBestMaterial(val3, val4, out var material))
					{
						return material;
					}
				}
				bool flag = Object.op_Implicit((Object)(object)GetParent(value));
				bool flag2 = Object.op_Implicit((Object)(object)GetParent(newObject));
				if (!flag && flag2)
				{
					return value;
				}
				if (flag)
				{
					return newObject;
				}
				return newObject;
			}

			private static bool FindBestMaterial(Material cachedMaterial, Material newMaterial, out Object material)
			{
				string name = ((Object)cachedMaterial.shader).name;
				string name2 = ((Object)newMaterial.shader).name;
				if (name == "Hidden/InternalErrorShader" && name2 != "Hidden/InternalErrorShader")
				{
					material = (Object)(object)newMaterial;
					return true;
				}
				if (name != "Hidden/InternalErrorShader" && name2 == "Hidden/InternalErrorShader")
				{
					material = (Object)(object)cachedMaterial;
					return true;
				}
				material = null;
				return false;
			}

			private static Dictionary<string, Object> GetCachedMap(Type type)
			{
				if (dictionaryCache.TryGetValue(type, out var value))
				{
					return value;
				}
				return InitCache(type);
			}

			private static Dictionary<string, Object> InitCache(Type type)
			{
				Dictionary<string, Object> dictionary = new Dictionary<string, Object>();
				Object[] array = Resources.FindObjectsOfTypeAll(type);
				foreach (Object val in array)
				{
					string name = val.name;
					dictionary[name] = FindBestAsset(dictionary, val, name);
				}
				dictionaryCache[type] = dictionary;
				return dictionary;
			}

			public static void Clear()
			{
				dictionaryCache.Clear();
			}

			public static void Clear<T>() where T : Object
			{
				dictionaryCache.Remove(typeof(T));
			}
		}

		private static PrefabManager _instance;

		public static PrefabManager Instance => _instance ?? (_instance = new PrefabManager());

		internal GameObject PrefabContainer { get; private set; }

		internal Dictionary<string, CustomPrefab> Prefabs { get; } = new Dictionary<string, CustomPrefab>();

		internal ObjectDB MenuObjectDB { get; private set; }

		public static event Action OnVanillaPrefabsAvailable;

		public static event Action OnPrefabsRegistered;

		private PrefabManager()
		{
		}

		static PrefabManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Main.LogInit("PrefabManager");
			PrefabContainer = new GameObject("Prefabs");
			PrefabContainer.transform.parent = Main.RootObject.transform;
			PrefabContainer.SetActive(false);
			Main.Harmony.PatchAll(typeof(Patches));
			SceneManager.sceneUnloaded += delegate
			{
				Cache.Clear();
				Instance.MenuObjectDB = null;
			};
		}

		internal void Activate()
		{
		}

		internal bool AddPrefab(GameObject prefab, BepInPlugin sourceMod)
		{
			CustomPrefab customPrefab = new CustomPrefab(prefab, sourceMod);
			AddPrefab(customPrefab);
			return Prefabs.ContainsKey(((Object)prefab).name);
		}

		public void AddPrefab(GameObject prefab)
		{
			CustomPrefab customPrefab = new CustomPrefab(prefab, fixReference: false);
			AddPrefab(customPrefab);
		}

		public void AddPrefab(CustomPrefab customPrefab)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (!customPrefab.IsValid())
			{
				Logger.LogWarning(customPrefab.SourceMod, $"Custom prefab {customPrefab} is not valid");
				return;
			}
			string name = ((Object)customPrefab.Prefab).name;
			if (Prefabs.ContainsKey(name))
			{
				Logger.LogWarning(customPrefab.SourceMod, $"Prefab '{customPrefab}' already exists");
				return;
			}
			customPrefab.Prefab.transform.SetParent(PrefabContainer.transform, false);
			Prefabs.Add(name, customPrefab);
			AssetManager.Instance.AddAsset((Object)(object)customPrefab.Prefab, null);
		}

		public GameObject CreateEmptyPrefab(string name, bool addZNetView = true)
		{
			if (string.IsNullOrEmpty(name))
			{
				Logger.LogWarning("Failed to create prefab with invalid name: " + name);
				return null;
			}
			if (Object.op_Implicit((Object)(object)GetPrefab(name)))
			{
				Logger.LogWarning("Failed to create prefab, name already exists: " + name);
				return null;
			}
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)val).name = name;
			val.transform.parent = PrefabContainer.transform;
			if (addZNetView)
			{
				ZNetView val2 = val.AddComponent<ZNetView>();
				val2.m_persistent = true;
			}
			return val;
		}

		public GameObject CreateClonedPrefab(string name, string baseName)
		{
			if (string.IsNullOrEmpty(baseName))
			{
				Logger.LogWarning("Failed to clone prefab with invalid baseName: " + baseName);
				return null;
			}
			GameObject prefab = GetPrefab(baseName);
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				Logger.LogWarning("Failed to clone prefab, can not find base prefab with name: " + baseName);
				return null;
			}
			return CreateClonedPrefab(name, prefab);
		}

		public GameObject CreateClonedPrefab(string name, GameObject prefab)
		{
			if (string.IsNullOrEmpty(name))
			{
				Logger.LogWarning("Failed to clone prefab with invalid name: " + name);
				return null;
			}
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				Logger.LogWarning("Failed to clone prefab, base prefab is not valid");
				return null;
			}
			if (Object.op_Implicit((Object)(object)GetPrefab(name)))
			{
				Logger.LogWarning("Failed to clone prefab, name already exists: " + name);
				return null;
			}
			return AssetManager.Instance.ClonePrefab(prefab, name, PrefabContainer.transform);
		}

		public GameObject GetPrefab(string name)
		{
			if (Prefabs.TryGetValue(name, out var value))
			{
				return value.Prefab;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (Object.op_Implicit((Object)(object)ZNetScene.instance) && ZNetScene.instance.m_namedPrefabs.TryGetValue(stableHashCode, out var value2))
			{
				return value2;
			}
			if (Object.op_Implicit((Object)(object)ObjectDB.instance) && ObjectDB.instance.m_itemByHash.TryGetValue(stableHashCode, out var value3))
			{
				return value3;
			}
			return Cache.GetPrefab<GameObject>(name);
		}

		public void RemovePrefab(string name)
		{
			Prefabs.Remove(name);
		}

		public void DestroyPrefab(string name)
		{
			if (!Prefabs.TryGetValue(name, out var value))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
				if (ZNetScene.instance.m_namedPrefabs.TryGetValue(stableHashCode, out var value2))
				{
					ZNetScene.instance.m_prefabs.Remove(value2);
					ZNetScene.instance.m_nonNetViewPrefabs.Remove(value2);
					ZNetScene.instance.m_namedPrefabs.Remove(stableHashCode);
					ZNetScene.instance.Destroy(value2);
				}
			}
			if (Object.op_Implicit((Object)(object)value.Prefab))
			{
				Object.Destroy((Object)(object)value.Prefab);
			}
			Prefabs.Remove(name);
		}

		private void RegisterAllToZNetScene()
		{
			if (!Prefabs.Any())
			{
				return;
			}
			Logger.LogInfo($"Adding {Prefabs.Count} custom prefabs to the ZNetScene");
			List<CustomPrefab> list = new List<CustomPrefab>();
			foreach (CustomPrefab value in Prefabs.Values)
			{
				try
				{
					if (value.FixReference)
					{
						value.Prefab.FixReferences(recursive: true);
						value.FixReference = false;
					}
					RegisterToZNetScene(value.Prefab);
				}
				catch (Exception arg)
				{
					Logger.LogWarning(value?.SourceMod, $"Error caught while adding prefab {value}: {arg}");
					list.Add(value);
				}
			}
			foreach (CustomPrefab item in list)
			{
				if (Object.op_Implicit((Object)(object)item.Prefab))
				{
					DestroyPrefab(((Object)item.Prefab).name);
				}
			}
		}

		public void RegisterToZNetScene(GameObject gameObject)
		{
			ZNetScene instance = ZNetScene.instance;
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			string name = ((Object)gameObject).name;
			if (((Object)gameObject).name.StartsWith("JVLmock_"))
			{
				return;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (instance.m_namedPrefabs.ContainsKey(stableHashCode))
			{
				Logger.LogDebug("Prefab " + name + " already in ZNetScene");
				return;
			}
			if ((Object)(object)gameObject.GetComponent<ZNetView>() != (Object)null)
			{
				instance.m_prefabs.Add(gameObject);
			}
			else
			{
				instance.m_nonNetViewPrefabs.Add(gameObject);
			}
			instance.m_namedPrefabs.Add(stableHashCode, gameObject);
			Logger.LogDebug("Added prefab " + name);
		}

		private void InvokeOnVanillaObjectsAvailable()
		{
			PrefabManager.OnVanillaPrefabsAvailable?.SafeInvoke();
		}

		private void InvokeOnPrefabsRegistered()
		{
			PrefabManager.OnPrefabsRegistered?.SafeInvoke();
		}

		private static bool TryFindAssetOfComponent(Component unityObject, Type objectType, out Object asset)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			Type type = ((object)unityObject).GetType();
			ClassMember classMember = ClassMember.GetClassMember(type);
			foreach (MemberBase member in classMember.Members)
			{
				if (member.MemberType == objectType && member.HasGetMethod)
				{
					asset = (Object)member.GetValue(unityObject);
					if (asset != (Object)null)
					{
						return Object.op_Implicit(asset);
					}
				}
			}
			asset = null;
			return false;
		}

		internal static bool TryFindAssetInSelfOrChildComponents(GameObject unityObject, Type objectType, out Object asset)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)unityObject))
			{
				asset = null;
				return false;
			}
			if (objectType.IsSubclassOf(typeof(Component)))
			{
				Component component = unityObject.GetComponent(objectType);
				if (Object.op_Implicit((Object)(object)component))
				{
					asset = (Object)(object)component;
					return true;
				}
			}
			Component[] components = unityObject.GetComponents<Component>();
			foreach (Component val in components)
			{
				if (!(val is Transform) && TryFindAssetOfComponent(val, objectType, out asset))
				{
					return Object.op_Implicit(asset);
				}
			}
			foreach (Transform item in unityObject.transform)
			{
				Transform val2 = item;
				if (TryFindAssetInSelfOrChildComponents(((Component)val2).gameObject, objectType, out asset))
				{
					return Object.op_Implicit(asset);
				}
			}
			asset = null;
			return false;
		}
	}
	public class RenderManager : IManager
	{
		private class RenderObject
		{
			public readonly GameObject Spawn;

			public readonly Vector3 Size;

			public RenderRequest Request;

			public RenderObject(GameObject spawn, Vector3 size)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				Spawn = spawn;
				Size = size;
			}
		}

		private class CreateTemporaryRenderTexture : IDisposable
		{
			private readonly Camera camera;

			private readonly RenderTexture previousRenderTexture;

			private readonly RenderTexture temporaryRenderTexture;

			public CreateTemporaryRenderTexture(Camera camera, int textureWidth, int textureHeight)
			{
				this.camera = camera;
				previousRenderTexture = RenderTexture.active;
				temporaryRenderTexture = RenderTexture.GetTemporary(textureWidth, textureHeight);
				camera.targetTexture = temporaryRenderTexture;
				RenderTexture.active = temporaryRenderTexture;
			}

			public void Dispose()
			{
				RenderTexture.active = previousRenderTexture;
				camera.targetTexture = null;
				RenderTexture.ReleaseTemporary(temporaryRenderTexture);
			}
		}

		public class RenderRequest
		{
			public readonly GameObject Target;

			public int Width { get; set; } = 128;

			public int Height { get; set; } = 128;

			public Quaternion Rotation { get; set; } = Quaternion.identity;

			public float FieldOfView { get; set; } = 0.5f;

			public float DistanceMultiplier { get; set; } = 1f;

			[Obsolete]
			public Action<Sprite> Callback { get; internal set; }

			public BepInPlugin TargetPlugin { get; set; }

			public bool UseCache { get; set; }

			public float ParticleSimulationTime { get; set; } = 5f;

			public RenderRequest(GameObject target)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				Target = target;
			}
		}

		public static readonly Quaternion IsometricRotation;

		private static RenderManager _instance;

		private static string cacheRevision;

		private static Dictionary<Type, List<Type>> componentDependencies;

		private const int Layer = 31;

		private Camera Renderer;

		private Light Light;

		private Sprite EmptySprite { get; } = Sprite.Create(Texture2D.whiteTexture, Rect.zero, Vector2.one);

		public static RenderManager Instance => _instance ?? (_instance = new RenderManager());

		private RenderManager()
		{
		}//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)


		static RenderManager()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			IsometricRotation = Quaternion.Euler(23f, 51f, 25.8f);
			cacheRevision = "c1";
			componentDependencies = new Dictionary<Type, List<Type>>();
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("RenderManager");
			if (!GUIUtils.IsHeadless)
			{
				((MonoBehaviour)Main.Instance).StartCoroutine(ClearRenderRoutine());
			}
		}

		[Obsolete("Use Render instead")]
		public bool EnqueueRender(GameObject target, Action<Sprite> callback)
		{
			return EnqueueRender(new RenderRequest(target), callback);
		}

		[Obsolete("Use Render instead")]
		public bool EnqueueRender(RenderRequest renderRequest, Action<Sprite> callback)
		{
			if (!Object.op_Implicit((Object)(object)renderRequest.Target))
			{
				throw new ArgumentException("Target is required");
			}
			if (callback == null)
			{
				throw new ArgumentException("Callback is required");
			}
			if (!renderRequest.Target.GetComponentsInChildren<Component>(false).Any(IsVisualComponent))
			{
				callback(null);
				return false;
			}
			renderRequest.Callback = callback;
			callback?.Invoke(Render(renderRequest));
			return true;
		}

		[Obsolete("Use Render instead")]
		public bool EnqueueRender(GameObject target, Action<Sprite> callback, int width = 128, int height = 128)
		{
			return EnqueueRender(new RenderRequest(target)
			{
				Width = width,
				Height = height
			}, callback);
		}

		public Sprite Render(GameObject target)
		{
			return Render(new RenderRequest(target));
		}

		public Sprite Render(GameObject target, Quaternion rotation)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return Render(new RenderRequest(target)
			{
				Rotation = rotation
			});
		}

		public Sprite Render(RenderRequest renderRequest)
		{
			if (!Object.op_Implicit((Object)(object)renderRequest.Target))
			{
				throw new ArgumentException("Target is required");
			}
			if (!renderRequest.Target.GetComponentsInChildren<Component>(false).Any(IsVisualComponent))
			{
				return null;
			}
			if (GUIUtils.IsHeadless)
			{
				return EmptySprite;
			}
			if (renderRequest.UseCache && ContainsIconCache(renderRequest.Target, renderRequest.TargetPlugin, out var sprite))
			{
				return sprite;
			}
			if (!Object.op_Implicit((Object)(object)Renderer))
			{
				SetupRendering();
			}
			RenderObject renderObject = SpawnRenderClone(renderRequest);
			if (renderObject == null)
			{
				return null;
			}
			Sprite val = RenderSprite(renderObject);
			if (renderRequest.UseCache)
			{
				CacheIcon(renderRequest.Target, renderRequest.TargetPlugin, val);
			}
			return val;
		}

		private bool ContainsIconCache(GameObject target, BepInPlugin plugin, out Sprite sprite)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			string version = GetVersion(plugin);
			string cachePath = GetCachePath(((Object)target).name, version);
			if (!File.Exists(cachePath))
			{
				sprite = null;
				return false;
			}
			byte[] data = File.ReadAllBytes(cachePath);
			Texture2D val = AssetUtils.LoadImage(data);
			sprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), Vector2.one / 2f);
			return true;
		}

		private void CacheIcon(GameObject target, BepInPlugin plugin, Sprite rendered)
		{
			string version = GetVersion(plugin);
			Directory.CreateDirectory(Paths.IconCachePath);
			File.WriteAllBytes(GetCachePath(((Object)target).name, version), ImageConversion.EncodeToPNG(rendered.texture));
		}

		private string GetCachePath(string name, string version)
		{
			return Path.Combine(Paths.IconCachePath, name + "-" + version + "-" + cacheRevision + ".png");
		}

		private string GetVersion(BepInPlugin plugin)
		{
			if (plugin != null)
			{
				return plugin.GUID + "-" + plugin.Version;
			}
			return GameVersions.ValheimVersion.ToString();
		}

		private Sprite RenderSprite(RenderObject renderObject)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			int width = renderObject.Request.Width;
			int height = renderObject.Request.Height;
			using (new CreateTemporaryRenderTexture(Renderer, width, height))
			{
				Renderer.fieldOfView = renderObject.Request.FieldOfView;
				renderObject.Spawn.SetActive(true);
				float num = Mathf.Max(renderObject.Size.x, renderObject.Size.y) + 0.1f;
				float num2 = num / Mathf.Tan(Renderer.fieldOfView * ((float)Math.PI / 180f)) * renderObject.Request.DistanceMultiplier;
				((Component)Renderer).transform.position = new Vector3(0f, 0f, num2);
				Renderer.Render();
				renderObject.Spawn.SetActive(false);
				Object.Destroy((Object)(object)renderObject.Spawn);
				Texture2D val = new Texture2D(width, height, (TextureFormat)4, false);
				val.ReadPixels(new Rect(0f, 0f, (float)width, (float)height), 0, 0);
				val.Apply();
				return Sprite.Create(val, new Rect(0f, 0f, (float)width, (float)height), Vector2.one / 2f);
			}
		}

		private IEnumerator ClearRenderRoutine()
		{
			while (true)
			{
				if (Object.op_Implicit((Object)(object)Renderer))
				{
					ClearRendering();
				}
				yield return null;
			}
		}

		private void SetupRendering()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			Renderer = new GameObject("Render Camera", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
			Renderer.backgroundColor = new Color(0f, 0f, 0f, 0f);
			Renderer.clearFlags = (CameraClearFlags)2;
			((Component)Renderer).transform.position = Vector3.zero;
			((Component)Renderer).transform.rotation = Quaternion.Euler(0f, 180f, 0f);
			Renderer.fieldOfView = 0.5f;
			Renderer.farClipPlane = 100000f;
			Renderer.cullingMask = int.MinValue;
			Light = new GameObject("Render Light", new Type[1] { typeof(Light) }).GetComponent<Light>();
			((Component)Light).transform.position = Vector3.zero;
			((Component)Light).transform.rotation = Quaternion.Euler(5f, 180f, 5f);
			Light.type = (LightType)1;
			Light.cullingMask = int.MinValue;
		}

		private void ClearRendering()
		{
			Object.Destroy((Object)(object)((Component)Renderer).gameObject);
			Object.Destroy((Object)(object)((Component)Light).gameObject);
		}

		private static bool IsVisualComponent(Component component)
		{
			if (!(component is Renderer))
			{
				return component is MeshFilter;
			}
			return true;
		}

		private static bool IsRenderComponent(Component component)
		{
			if (!(component is MeshRenderer) && !(component is SkinnedMeshRenderer) && !(component is MeshFilter))
			{
				return component is Transform;
			}
			return true;
		}

		private static bool IsParticleComponent(Component component)
		{
			if (!(component is ParticleSystemRenderer))
			{
				return component is ParticleSystem;
			}
			return true;
		}

		private static RenderObject SpawnRenderClone(RenderRequest request)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject();
			val.SetActive(false);
			GameObject val2 = Object.Instantiate<GameObject>(request.Target, val.transform);
			if (!RecursivelyRemoveComponents(val.transform, request))
			{
				Logger.LogWarning($"Sprite could not be rendered for {request.Target} due to components not being removed.");
				return null;
			}
			SetLayerRecursive(val2);
			val2.transform.SetParent((Transform)null);
			Object.DestroyImmediate((Object)(object)val);
			val2.transform.position = Vector3.zero;
			val2.transform.rotation = request.Rotation;
			((Object)val2).name = ((Object)request.Target).name;
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(1000f, 1000f, 1000f);
			Vector3 val4 = default(Vector3);
			((Vector3)(ref val4))..ctor(-1000f, -1000f, -1000f);
			Renderer[] componentsInChildren = val2.GetComponentsInChildren<Renderer>();
			foreach (Renderer val5 in componentsInChildren)
			{
				if (val5 is MeshRenderer || val5 is SkinnedMeshRenderer)
				{
					Vector3 val6 = val3;
					Bounds bounds = val5.bounds;
					val3 = Vector3.Min(val6, ((Bounds)(ref bounds)).min);
					Vector3 val7 = val4;
					bounds = val5.bounds;
					val4 = Vector3.Max(val7, ((Bounds)(ref bounds)).max);
				}
			}
			val2.transform.position = -(val3 + val4) / 2f;
			Vector3 size = default(Vector3);
			((Vector3)(ref size))..ctor(Mathf.Abs(val3.x) + Mathf.Abs(val4.x), Mathf.Abs(val3.y) + Mathf.Abs(val4.y), Mathf.Abs(val3.z) + Mathf.Abs(val4.z));
			ParticleSystem[] componentsInChildren2 = val2.GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val8 in componentsInChildren2)
			{
				val8.Simulate(request.ParticleSimulationTime);
			}
			TimedDestruction val9 = val2.AddComponent<TimedDestruction>();
			val9.Trigger(1f);
			return new RenderObject(val2, size)
			{
				Request = request
			};
		}

		private static bool RecursivelyRemoveComponents(Transform parentTransform, RenderRequest request)
		{
			GameObject gameObject = ((Component)parentTransform).gameObject;
			for (int i = 0; i < parentTransform.childCount; i++)
			{
				RecursivelyRemoveComponents(parentTransform.GetChild(i), request);
			}
			List<Type> topolocialSort = GetTopolocialSort(parentTransform);
			if (topolocialSort == null)
			{
				return false;
			}
			foreach (Type item in topolocialSort)
			{
				Component[] components = gameObject.GetComponents(item);
				foreach (Component val in components)
				{
					if (!IsRenderComponent(val) && (!(request.ParticleSimulationTime >= 0f) || !IsParticleComponent(val)))
					{
						try
						{
							Object.DestroyImmediate((Object)(object)val);
						}
						catch (Exception ex)
						{
							Logger.LogError($"Component {val} could not be removed. Exception caught: {ex.Message}");
							return false;
						}
					}
				}
			}
			return true;
		}

		private static List<Type> GetTopolocialSort(Transform tranform)
		{
			List<Type> list = new List<Type>();
			HashSet<Type> visited = new HashSet<Type>();
			HashSet<Type> recursionStack = new HashSet<Type>();
			if (!Object.op_Implicit((Object)(object)tranform) || !Object.op_Implicit((Object)(object)((Component)tranform).gameObject))
			{
				return list;
			}
			Component[] components = ((Component)tranform).gameObject.GetComponents<Component>();
			foreach (Component val in components)
			{
				if (Object.op_Implicit((Object)(object)val) && !TopologicalSortUtil(((object)val).GetType(), visited, recursionStack, list))
				{
					Logger.LogWarning($"Cycles detected in component dependencies for type {((object)val).GetType()}. Unable to determine deletion order for {tranform}.");
					return null;
				}
			}
			list.Reverse();
			return list;
		}

		private static bool TopologicalSortUtil(Type node, HashSet<Type> visited, HashSet<Type> recursionStack, List<Type> result)
		{
			if (visited.Contains(node))
			{
				return true;
			}
			List<Type> list = null;
			int num = result.FindIndex(node.IsSubclassOf);
			if (num != -1)
			{
				list = result.Skip(num).ToList();
				result.RemoveRange(num, result.Count - num);
			}
			if (recursionStack.Contains(node))
			{
				return false;
			}
			recursionStack.Add(node);
			List<Type> list2 = GetComponentDependencies(node);
			foreach (Type item in list2)
			{
				if (!TopologicalSortUtil(item, visited, recursionStack, result))
				{
					return false;
				}
			}
			if (list != null)
			{
				result.AddRange(list);
			}
			else
			{
				result.Add(node);
			}
			recursionStack.Remove(node);
			visited.Add(node);
			return true;
		}

		private static List<Type> GetComponentDependencies(Type node)
		{
			if (!componentDependencies.TryGetValue(node, out var value))
			{
				value = new List<Type>();
				foreach (RequireComponent customAttribute in ((MemberInfo)node).GetCustomAttributes<RequireComponent>(inherit: true))
				{
					value.Add(customAttribute.m_Type0);
					value.Add(customAttribute.m_Type1);
					value.Add(customAttribute.m_Type2);
				}
				value = value.Where((Type t) => t != null).Distinct().ToList();
				componentDependencies[node] = value;
			}
			return value;
		}

		private static void SetLayerRecursive(GameObject root)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			root.layer = 31;
			foreach (Transform item in root.transform)
			{
				Transform val = item;
				SetLayerRecursive(((Component)val).gameObject);
			}
		}
	}
	public class SkillManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(Skills), "Awake")]
			[HarmonyPostfix]
			private static void RegisterCustomSkills(Skills __instance)
			{
				Instance.RegisterCustomSkills(__instance);
			}

			[HarmonyPatch(typeof(Skills), "IsSkillValid")]
			[HarmonyPostfix]
			private static void Skills_IsSkillValid(Skills __instance, SkillType type, ref bool __result)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Instance.Skills_IsSkillValid(__instance, type, ref __result);
			}

			[HarmonyPatch(typeof(Skills), "GetSkill")]
			[HarmonyPrefix]
			private static void Skills_GetSkill(Skills __instance, ref SkillType skillType)
			{
				Instance.Skills_GetSkill(__instance, ref skillType);
			}

			[HarmonyPatch(typeof(Skills), "CheatRaiseSkill")]
			[HarmonyPrefix]
			private static bool Skills_CheatRaiseSkill(Skills __instance, string name, float value)
			{
				return Instance.Skills_CheatRaiseSkill(__instance, name, value);
			}

			[HarmonyPatch(typeof(Skills), "CheatResetSkill")]
			[HarmonyPrefix]
			private static bool Skills_CheatResetSkill(Skills __instance, string name)
			{
				return Instance.Skills_CheatResetSkill(__instance, name);
			}

			[HarmonyPatch(typeof(Terminal), "Awake")]
			[HarmonyPostfix]
			private static void Terminal_InitTerminal()
			{
				Instance.AddSkillsToTerminal();
			}
		}

		private static SkillManager _instance;

		private bool addedSkillsToTerminal;

		internal Dictionary<SkillType, SkillConfig> CustomSkills = new Dictionary<SkillType, SkillConfig>();

		public static SkillManager Instance => _instance ?? (_instance = new SkillManager());

		private SkillManager()
		{
		}

		static SkillManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("SkillManager");
			Main.Harmony.PatchAll(typeof(Patches));
		}

		public SkillType AddSkill(SkillConfig skillConfig)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(skillConfig?.Identifier))
			{
				Logger.LogError("Failed to register skill with invalid identifier: " + skillConfig?.Identifier);
				return (SkillType)0;
			}
			CustomSkills.Add(skillConfig.UID, skillConfig);
			return skillConfig.UID;
		}

		[Obsolete("Use AddSkill(SkillConfig) instead")]
		public SkillType AddSkill(string identifer, string name, string description, float increaseStep = 1f, Sprite icon = null)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			return AddSkill(new SkillConfig
			{
				Identifier = identifer,
				Name = name,
				Description = description,
				IncreaseStep = increaseStep,
				Icon = icon
			});
		}

		public void AddSkillsFromJson(string path)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			string text = AssetUtils.LoadText(path);
			if (string.IsNullOrEmpty(text))
			{
				Logger.LogError("Failed to load skills from json: " + path);
				return;
			}
			List<SkillConfig> list = SkillConfig.ListFromJson(text);
			foreach (SkillConfig item in list)
			{
				AddSkill(item);
			}
		}

		public SkillDef GetSkill(SkillType skillType)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (CustomSkills.ContainsKey(skillType))
			{
				return CustomSkills[skillType].ToSkillDef();
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer == null)
			{
				return null;
			}
			return ((Character)localPlayer).GetSkills()?.m_skills?.FirstOrDefault((Func<SkillDef, bool>)((SkillDef skill) => skill.m_skill == skillType));
		}

		public SkillDef GetSkill(string identifier)
		{
			if (string.IsNullOrEmpty(identifier))
			{
				return null;
			}
			return GetSkill((SkillType)Math.Abs(StringExtensionMethods.GetStableHashCode(identifier)));
		}

		private void RegisterCustomSkills(Skills self)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (CustomSkills.Count <= 0)
			{
				return;
			}
			Logger.LogInfo($"Registering {CustomSkills.Count} custom skills");
			foreach (SkillConfig value in CustomSkills.Values)
			{
				LocalizationManager.Instance.JotunnLocalization.AddTranslation($"skill_{value.UID}", value.LocalizedName);
				self.m_skills.Add(value.ToSkillDef());
				Logger.LogDebug("Registered skill " + value.Name + " | ID: " + value.Identifier);
			}
		}

		private void Skills_IsSkillValid(Skills self, SkillType skillType, ref bool result)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected I4, but got Unknown
			result = result || CustomSkills.ContainsKey((SkillType)Math.Abs((int)skillType));
		}

		private void Skills_GetSkill(Skills self, ref SkillType skillType)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected I4, but got Unknown
			SkillType val = (SkillType)Math.Abs((int)skillType);
			if ((int)skillType < 0 && CustomSkills.ContainsKey(val))
			{
				skillType = (SkillType)(int)val;
			}
		}

		private bool Skills_CheatRaiseSkill(Skills self, string name, float value)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			foreach (SkillConfig value2 in CustomSkills.Values)
			{
				if (value2.IsFromName(name))
				{
					Skill skill = self.GetSkill(value2.UID);
					string localizedName = value2.LocalizedName;
					skill.m_level += value;
					skill.m_level = Mathf.Clamp(skill.m_level, 0f, 100f);
					((Character)self.m_player).Message((MessageType)1, $"Skill increased {localizedName}: {(int)skill.m_level}", 0, skill.m_info.m_icon);
					Console.instance.Print($"Skill {localizedName} = {skill.m_level}");
					Logger.LogDebug($"Raised skill {localizedName} to {skill.m_level}");
					return false;
				}
			}
			return true;
		}

		private bool Skills_CheatResetSkill(Skills self, string name)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			foreach (SkillConfig value in CustomSkills.Values)
			{
				if (value.IsFromName(name))
				{
					((Character)self.m_player).GetSkills().ResetSkill(value.UID);
					Console.instance.Print("Skill " + value.LocalizedName + " reset");
					Logger.LogDebug("Reset skill " + value.Name);
					return false;
				}
			}
			return true;
		}

		private void AddSkillsToTerminal()
		{
			if (Terminal.m_terminalInitialized && !addedSkillsToTerminal)
			{
				addedSkillsToTerminal = true;
				AddSkillOptions("raiseskill");
				AddSkillOptions("resetskill");
			}
		}

		private void AddSkillOptions(string commandName)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			if (Terminal.commands.TryGetValue(commandName, out var value))
			{
				ConsoleOptionsFetcher fetcher = value.m_tabOptionsFetcher;
				value.m_tabOptionsFetcher = (ConsoleOptionsFetcher)delegate
				{
					List<string> list = fetcher.Invoke();
					list.AddRange(CustomSkills.Values.Select((SkillConfig skill) => skill.LocalizedName));
					return list;
				};
			}
			else
			{
				Logger.LogWarning("Failed to find " + commandName + " command");
			}
		}
	}
	public class SynchronizationManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(ZNet), "Awake")]
			[HarmonyPostfix]
			private static void ZNet_Awake(ZNet __instance)
			{
				Instance.ZNet_Awake(__instance);
			}

			[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
			[HarmonyPrefix]
			private static void ZNet_RPC_Pre_PeerInfo(ZNet __instance, ZRpc rpc, ref SocketBuffer __state)
			{
				Instance.ZNet_RPC_Pre_PeerInfo(__instance, rpc, ref __state);
			}

			[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
			[HarmonyPostfix]
			private static void ZNet_RPC_Post_PeerInfo(ZNet __instance, ZRpc rpc, ref SocketBuffer __state)
			{
				Instance.ZNet_RPC_Post_PeerInfo(__instance, rpc, ref __state);
			}

			public static bool Socket_VersionMatch_Prefix(ISocket __instance, bool __runOriginal)
			{
				if (__runOriginal)
				{
					return Instance.Socket_VersionMatch(__instance);
				}
				return false;
			}

			public static bool Socket_Send_Prefix(ISocket __instance, ZPackage pkg, bool __runOriginal)
			{
				if (__runOriginal)
				{
					return Instance.Socket_Send(__instance, pkg);
				}
				return false;
			}

			[HarmonyPatch(typeof(SyncedList), "Load")]
			[HarmonyPostfix]
			private static void SyncedList_Load(SyncedList __instance)
			{
				Instance.SyncedList_Load(__instance);
			}

			[HarmonyPatch(typeof(SyncedList), "Save")]
			[HarmonyPostfix]
			private static void SyncedList_Save(SyncedList __instance)
			{
				Instance.SyncedList_Save(__instance);
			}

			[HarmonyPatch(typeof(Menu), "IsVisible")]
			[HarmonyPostfix]
			private static void Menu_IsVisible(ref bool __result)
			{
				Instance.Menu_IsVisible(ref __result);
			}

			[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
			[HarmonyPrefix]
			private static bool GetCachedValueForSyncedConfigs(ConfigEntryBase __instance, ref string __result)
			{
				return ConfigEntryBase_GetSerializedValue(__instance, ref __result);
			}

			[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
			[HarmonyPrefix]
			private static bool BlockSetForSyncedConfigs(ConfigEntryBase __instance)
			{
				return ConfigEntryBase_SetSerializedValue(__instance);
			}

			[HarmonyPatch(typeof(ZNet), "Start")]
			[HarmonyPrefix]
			private static void ZNet_Start(ZNet __instance)
			{
				Instance.InitAdminState(__instance);
				Instance.SubscribeToConfigReload();
			}

			[HarmonyPatch(typeof(ZNet), "OnDestroy")]
			[HarmonyPrefix]
			private static void Znet_OnDestroy(ZNet __instance)
			{
				Instance.UnsubscribeToConfigReload();
				Instance.ResetAdminState(__instance);
			}
		}

		private class SocketBuffer
		{
			public volatile bool finished;

			public volatile int versionMatchPackageIndex = -1;

			public List<ZPackage> packages = new List<ZPackage>();
		}

		private CustomRPC ConfigRPC;

		private CustomRPC AdminRPC;

		private List<Tuple<CustomRPC, Func<ZNetPeer, ZPackage>>> InitialSync = new List<Tuple<CustomRPC, Func<ZNetPeer, ZPackage>>>();

		internal readonly Dictionary<ConfigEntryBase, object> localValues = new Dictionary<ConfigEntryBase, object>();

		private readonly Dictionary<string, bool> CachedAdminStates = new Dictionary<string, bool>();

		private readonly Dictionary<string, ConfigFile> CustomConfigs = new Dictionary<string, ConfigFile>();

		private HashSet<Tuple<string, string, string, string>> CachedConfigValues = new HashSet<Tuple<string, string, string, string>>();

		private readonly Dictionary<string, string> CachedCustomConfigGUIDs = new Dictionary<string, string>();

		private bool ConfigurationManagerWindowShown;

		private Dictionary<string, SocketBuffer> socketBuffers = new Dictionary<string, SocketBuffer>();

		private HashSet<string> modNotLoadedConfigsWarnings = new HashSet<string>();

		private static SynchronizationManager _instance;

		private const byte INITIAL_CONFIG = 64;

		public static SynchronizationManager Instance => _instance ?? (_instance = new SynchronizationManager());

		public bool PlayerIsAdmin { get; private set; } = true;

		public static event EventHandler<ConfigurationSynchronizationEventArgs> OnConfigurationSynchronized;

		public static event EventHandler<SyncingConfigurationEventArgs> OnSyncingConfiguration;

		public static event Action OnAdminStatusChanged;

		public static event Action OnConfigurationWindowClosed;

		private SynchronizationManager()
		{
		}

		void IManager.Init()
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			Main.LogInit("SynchronizationManager");
			AdminRPC = NetworkManager.Instance.AddRPC(((BaseUnityPlugin)Main.Instance).Info.Metadata, "AdminStatus", null, AdminRPC_OnClientReceive);
			ConfigRPC = NetworkManager.Instance.AddRPC(((BaseUnityPlugin)Main.Instance).Info.Metadata, "ConfigSync", ConfigRPC_OnServerReceive, ConfigRPC_OnClientReceive);
			Main.Harmony.PatchAll(typeof(Patches));
			HarmonyMethod val = new HarmonyMethod(typeof(Patches).GetMethod("Socket_Send_Prefix"));
			HarmonyMethod val2 = new HarmonyMethod(typeof(Patches).GetMethod("Socket_VersionMatch_Prefix"));
			Type type = typeof(Game).Assembly.GetType("ZSteamSocket");
			if (type != null)
			{
				Main.Harmony.Patch((MethodBase)type.GetMethod("Send", new Type[1] { typeof(ZPackage) }), val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Main.Harmony.Patch((MethodBase)type.GetMethod("VersionMatch"), val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			Type type2 = typeof(Game).Assembly.GetType("ZPlayFabSocket");
			if (type2 != null)
			{
				Main.Harmony.Patch((MethodBase)type2.GetMethod("Send", new Type[1] { typeof(ZPackage) }), val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Main.Harmony.Patch((MethodBase)type2.GetMethod("VersionMatch"), val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			if (Object.op_Implicit((Object)(object)ConfigManagerUtils.Plugin))
			{
				EventInfo eventInfo = ((object)ConfigManagerUtils.Plugin).GetType().GetEvent("DisplayingWindowChanged");
				if (eventInfo != null)
				{
					Action<object, object> action = ConfigurationManager_DisplayingWindowChanged;
					Delegate handler = Delegate.CreateDelegate(eventInfo.EventHandlerType, action.Target, action.Method);
					eventInfo.AddEventHandler(ConfigManagerUtils.Plugin, handler);
				}
			}
			AddInitialSynchronization(AdminRPC, delegate(ZNetPeer peer)
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected O, but got Unknown
				string hostName = peer.m_socket.GetHostName();
				bool flag = !string.IsNullOrEmpty(hostName) && ZNet.instance.ListContainsId(ZNet.instance.m_adminList, hostName);
				Logger.LogDebug("Admin status: " + (flag ? "Admin" : "No Admin"));
				ZPackage val3 = new ZPackage();
				val3.Write(flag);
				return val3;
			});
			AddInitialSynchronization(ConfigRPC, () => GenerateConfigZPackage(initial: true, GetSyncConfigValues().ToList()));
		}

		public void RegisterCustomConfig(ConfigFile customFile)
		{
			if (!customFile.ConfigFilePath.StartsWith(Paths.ConfigPath))
			{
				throw new ArgumentException("Config file must be saved under the BepInEx config folder. " + customFile.ConfigFilePath);
			}
			string fileIdentifier = GetFileIdentifier(customFile);
			if (IsDefaultModConfig(fileIdentifier, out var modGUID))
			{
				throw new ArgumentException("Config file must not be a default mod config: " + modGUID + ". It is already synchronized");
			}
			if (CustomConfigs.ContainsKey(fileIdentifier))
			{
				throw new ArgumentException("Config file already registered. " + customFile.ConfigFilePath);
			}
			Logger.LogDebug("Registering custom config file " + fileIdentifier);
			CustomConfigs.Add(fileIdentifier, customFile);
			BepInPlugin sourceModMetadata = BepInExUtils.GetSourceModMetadata();
			CachedCustomConfigGUIDs.Add(fileIdentifier, sourceModMetadata.GUID);
		}

		public void AddInitialSynchronization(CustomRPC rpc, Func<ZNetPeer, ZPackage> packageGenerator)
		{
			InitialSync.Add(new Tuple<CustomRPC, Func<ZNetPeer, ZPackage>>(rpc, packageGenerator));
		}

		public void AddInitialSynchronization(CustomRPC rpc, Func<ZPackage> packageGenerator)
		{
			AddInitialSynchronization(rpc, (ZNetPeer peer) => packageGenerator());
		}

		private void InitAdminState(ZNet zNet)
		{
			CacheConfigurationValues();
			if (Object.op_Implicit((Object)(object)zNet) && zNet.IsServer())
			{
				PlayerIsAdmin = true;
				UnlockConfigurationEntries();
				return;
			}
			PlayerIsAdmin = false;
			InitAdminConfigs();
			LockConfigurationEntries();
			SetToDefaultConfigEntries();
		}

		private void ResetAdminState(ZNet zNet)
		{
			PlayerIsAdmin = true;
			UnlockConfigurationEntries();
			ResetAdminConfigs(zNet);
		}

		private void InitAdminConfigs()
		{
			foreach (ConfigFile configFile in GetConfigFiles())
			{
				foreach (ConfigDefinition key in configFile.Keys)
				{
					ConfigEntryBase val = configFile[key.Section, key.Key];
					ConfigurationManagerAttributes configurationManagerAttributes = val.GetConfigurationManagerAttributes();
					if (configurationManagerAttributes != null && configurationManagerAttributes.IsAdminOnly && val.BoxedValue != null)
					{
						localValues[val] = val.BoxedValue;
					}
				}
			}
		}

		private void ResetAdminConfigs(ZNet zNet)
		{
			if (Object.op_Implicit((Object)(object)zNet) && !zNet.IsServer())
			{
				foreach (KeyValuePair<ConfigEntryBase, object> localValue in localValues)
				{
					localValue.Key.BoxedValue = localValue.Value;
				}
			}
			localValues.Clear();
		}

		private void ZNet_Awake(ZNet self)
		{
			if (self.IsServer())
			{
				((MonoBehaviour)self).StartCoroutine(AdminListWatchdog(self));
			}
		}

		private IEnumerator AdminListWatchdog(ZNet znet)
		{
			while (Object.op_Implicit((Object)(object)znet) && Object.op_Implicit((Object)(object)((Component)znet).gameObject))
			{
				yield return (object)new WaitForSeconds(5f);
				SyncedList adminList = znet.m_adminList;
				if (adminList != null)
				{
					adminList.CheckLoad();
				}
			}
		}

		private void ZNet_RPC_Pre_PeerInfo(ZNet znet, ZRpc rpc, ref SocketBuffer __state)
		{
			if (znet.IsServer())
			{
				string endPointString = rpc.GetSocket().GetEndPointString();
				if (!string.IsNullOrEmpty(endPointString))
				{
					__state = new SocketBuffer();
					socketBuffers[endPointString] = __state;
				}
			}
		}

		private void ZNet_RPC_Post_PeerInfo(ZNet self, ZRpc rpc, ref SocketBuffer __state)
		{
			if (self.IsServer())
			{
				ZNetPeer peer = self.GetPeer(rpc);
				if (peer == null || !peer.IsReady())
				{
					Logger.LogInfo("Peer has disconnected. Skipping initial data send.");
				}
				else
				{
					((MonoBehaviour)self).StartCoroutine(SynchronizeInitialData(peer, __state));
				}
			}
		}

		private IEnumerator SynchronizeInitialData(ZNetPeer peer, SocketBuffer socketBuffer)
		{
			Logger.LogInfo($"Sending initial data to peer #{peer.m_uid}");
			foreach (Tuple<CustomRPC, Func<ZNetPeer, ZPackage>> item3 in InitialSync)
			{
				CustomRPC item = item3.Item1;
				Func<ZNetPeer, ZPackage> item2 = item3.Item2;
				ZPackage val = item2(peer);
				if (val != null && val.Size() > 0)
				{
					yield return ((MonoBehaviour)ZNet.instance).StartCoroutine(item.SendPackageRoutine(peer.m_uid, val));
				}
			}
			if (socketBuffer == null)
			{
				yield break;
			}
			socketBuffer.finished = true;
			ISocket socket = peer.m_rpc.GetSocket();
			for (int i = 0; i < socketBuffer.packages.Count; i++)
			{
				if (i == socketBuffer.versionMatchPackageIndex)
				{
					socket.VersionMatch();
				}
				ZPackage val2 = socketBuffer.packages[i];
				socket.Send(val2);
			}
			if (socketBuffer.packages.Count == socketBuffer.versionMatchPackageIndex)
			{
				socket.VersionMatch();
			}
		}

		private void SyncedList_Save(SyncedList self)
		{
			if ((Object)(object)ZNet.instance != (Object)null && self == ZNet.instance.m_adminList)
			{
				SynchronizeAdminStatus();
			}
		}

		private void SyncedList_Load(SyncedList self)
		{
			if ((Object)(object)ZNet.instance != (Object)null && self == ZNet.instance.m_adminList)
			{
				SynchronizeAdminStatus();
			}
		}

		private void SynchronizeAdminStatus()
		{
			if (!ZNet.instance.IsServerInstance() && !ZNet.instance.IsLocalInstance())
			{
				return;
			}
			List<string> list = ZNet.instance.m_adminList.m_list.ToList();
			foreach (string item in list)
			{
				if (!CachedAdminStates.ContainsKey(item))
				{
					SendAdminStateToClient(item, admin: true);
					CachedAdminStates.Add(item, value: true);
				}
				else if (!CachedAdminStates[item])
				{
					SendAdminStateToClient(item, admin: true);
				}
			}
			foreach (string item2 in CachedAdminStates.Keys.ToList())
			{
				if (!list.Contains(item2))
				{
					if (CachedAdminStates[item2])
					{
						SendAdminStateToClient(item2, admin: false);
					}
					CachedAdminStates.Remove(item2);
				}
			}
		}

		private void SendAdminStateToClient(string entry, bool admin)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			long? num = ((IEnumerable<ZNetPeer>)ZNet.instance.m_peers).FirstOrDefault((Func<ZNetPeer, bool>)((ZNetPeer x) => x.m_socket.GetHostName().EndsWith(entry)))?.m_uid;
			if (num.HasValue)
			{
				Logger.LogInfo(string.Format("Sending admin status to {0}/{1} ({2})", entry, num, admin ? "is admin" : "is no admin"));
				ZPackage val = new ZPackage();
				val.Write(admin);
				AdminRPC.SendPackage(num.Value, val);
			}
		}

		private IEnumerator AdminRPC_OnClientReceive(long sender, ZPackage package)
		{
			bool flag = package.ReadBool();
			Logger.LogInfo("Received admin status from server: " + (flag ? "Admin" : "No Admin"));
			Instance.PlayerIsAdmin = flag;
			InvokeOnAdminStatusChanged();
			if (flag)
			{
				UnlockConfigurationEntries();
			}
			else
			{
				LockConfigurationEntries();
			}
			yield break;
		}

		private void InvokeOnAdminStatusChanged()
		{
			SynchronizationManager.OnAdminStatusChanged?.SafeInvoke();
		}

		private IEnumerable<ConfigFile> GetConfigFiles()
		{
			Dictionary<string, BaseUnityPlugin> dependentPlugins = BepInExUtils.GetDependentPlugins(includeJotunn: true);
			foreach (BaseUnityPlugin value in dependentPlugins.Values)
			{
				yield return value.Config;
			}
			foreach (ConfigFile value2 in CustomConfigs.Values)
			{
				yield return value2;
			}
		}

		private bool ShouldManageConfig(ConfigFile config)
		{
			if (!GetPluginGUID(config, out var pluginGUID))
			{
				return false;
			}
			if (!BepInExUtils.GetDependentPlugins().TryGetValue(pluginGUID, out var value))
			{
				return false;
			}
			return ShouldManageConfig(value);
		}

		private bool ShouldManageConfig(BaseUnityPlugin plugin)
		{
			if (ModCompatibility.IsModuleOnServer(plugin))
			{
				return true;
			}
			return plugin.GetSynchronizationModeAttribute()?.ShouldAlwaysEnforceAdminOnly() ?? true;
		}

		private static string GetFileIdentifier(ConfigFile config)
		{
			return config.ConfigFilePath.Replace(Paths.ConfigPath, "").Replace("\\", "/").Trim(new char[1] { '/' });
		}

		private bool GetPluginGUID(ConfigFile config, out string pluginGUID)
		{
			string fileIdentifier = GetFileIdentifier(config);
			return GetPluginGUID(fileIdentifier, out pluginGUID);
		}

		private bool GetPluginGUID(string configFileIdentifier, out string pluginGUID)
		{
			if (IsDefaultModConfig(configFileIdentifier, out pluginGUID))
			{
				return true;
			}
			if (CachedCustomConfigGUIDs.ContainsKey(configFileIdentifier))
			{
				pluginGUID = CachedCustomConfigGUIDs[configFileIdentifier];
				return true;
			}
			return false;
		}

		private ConfigFile GetConfigFile(string identifier)
		{
			if (CustomConfigs.TryGetValue(identifier, out var value))
			{
				return value;
			}
			Dictionary<string, BaseUnityPlugin> dependentPlugins = BepInExUtils.GetDependentPlugins(includeJotunn: true);
			if (IsDefaultModConfig(identifier, out var modGUID) && dependentPlugins.TryGetValue(modGUID, out var value2))
			{
				return value2.Config;
			}
			return null;
		}

		private static bool IsDefaultModConfig(string identifier, out string modGUID)
		{
			if (identifier.EndsWith(".cfg"))
			{
				modGUID = identifier.Substring(0, identifier.Length - 4);
				return Chainloader.PluginInfos.ContainsKey(modGUID);
			}
			modGUID = string.Empty;
			return false;
		}

		private void UnlockConfigurationEntries()
		{
			foreach (ConfigFile configFile in GetConfigFiles())
			{
				foreach (ConfigDefinition key in configFile.Keys)
				{
					ConfigEntryBase configEntry = configFile[key.Section, key.Key];
					ConfigurationManagerAttributes configurationManagerAttributes = configEntry.GetConfigurationManagerAttributes();
					if (configurationManagerAttributes != null && configurationManagerAttributes.IsAdminOnly)
					{
						configurationManagerAttributes.IsUnlocked = true;
					}
				}
			}
		}

		private void LockConfigurationEntries()
		{
			foreach (ConfigFile configFile in GetConfigFiles())
			{
				if (!ShouldManageConfig(configFile))
				{
					continue;
				}
				foreach (ConfigDefinition key in configFile.Keys)
				{
					ConfigEntryBase configEntry = configFile[key.Section, key.Key];
					ConfigurationManagerAttributes configurationManagerAttributes = configEntry.GetConfigurationManagerAttributes();
					if (configurationManagerAttributes != null && configurationManagerAttributes.IsAdminOnly)
					{
						configurationManagerAttributes.IsUnlocked = false;
					}
				}
			}
		}

		private void Menu_IsVisible(ref bool result)
		{
			result = result || ConfigurationManagerWindowShown;
		}

		private void ConfigurationManager_DisplayingWindowChanged(object sender, object e)
		{
			ConfigurationManagerWindowShown = ConfigManagerUtils.DisplayingWindow;
			if (!ConfigurationManagerWindowShown)
			{
				InvokeOnConfigurationWindowClosed();
				SynchronizeChangedConfig();
			}
		}

		private void InvokeOnConfigurationWindowClosed()
		{
			SynchronizationManager.OnConfigurationWindowClosed?.SafeInvoke();
		}

		private void SubscribeToConfigReload()
		{
			foreach (ConfigFile configFile in GetConfigFiles())
			{
				configFile.ConfigReloaded += Config_ConfigReloaded;
			}
		}

		private void UnsubscribeToConfigReload()
		{
			foreach (ConfigFile configFile in GetConfigFiles())
			{
				configFile.ConfigReloaded -= Config_ConfigReloaded;
			}
		}

		private void Config_ConfigReloaded(object sender, EventArgs e)
		{
			SynchronizeChangedConfig();
		}

		private static bool ConfigEntryBase_GetSerializedValue(ConfigEntryBase __instance, ref string __result)
		{
			if (ReadWriteConfigFromDisk() || !__instance.IsSyncable() || __instance.GetLocalValue() == null)
			{
				return true;
			}
			__result = TomlTypeConverter.ConvertToString(__instance.GetLocalValue(), __instance.SettingType);
			return false;
		}

		private static bool ConfigEntryBase_SetSerializedValue(ConfigEntryBase __instance)
		{
			if (!ReadWriteConfigFromDisk())
			{
				return !__instance.IsSyncable();
			}
			return true;
		}

		private static bool ReadWriteConfigFromDisk()
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return ZNet.instance.IsServer();
			}
			return true;
		}

		internal void CacheConfigurationValues()
		{
			CachedConfigValues = GetSyncConfigValues();
		}

		private HashSet<Tuple<string, string, string, string>> GetSyncConfigValues()
		{
			Logger.LogDebug("Gathering config values");
			HashSet<Tuple<string, string, string, string>> hashSet = new HashSet<Tuple<string, string, string, string>>();
			foreach (ConfigFile configFile in GetConfigFiles())
			{
				string fileIdentifier = GetFileIdentifier(configFile);
				foreach (ConfigDefinition key in configFile.Keys)
				{
					ConfigEntryBase val = configFile[key.Section, key.Key];
					ConfigurationManagerAttributes configurationManagerAttributes = val.GetConfigurationManagerAttributes();
					if (configurationManagerAttributes != null && configurationManagerAttributes.IsAdminOnly)
					{
						string item = TomlTypeConverter.ConvertToString(val.BoxedValue, val.SettingType);
						Tuple<string, string, string, string> item2 = new Tuple<string, string, string, string>(fileIdentifier, key.Section, key.Key, item);
						hashSet.Add(item2);
					}
				}
			}
			return hashSet;
		}

		internal void SynchronizeChangedConfig()
		{
			HashSet<Tuple<string, string, string, string>> hashSet = new HashSet<Tuple<string, string, string, string>>();
			foreach (ConfigFile configFile in GetConfigFiles())
			{
				string fileIdentifier = GetFileIdentifier(configFile);
				foreach (ConfigDefinition key in configFile.Keys)
				{
					ConfigEntryBase val = configFile[key];
					ConfigurationManagerAttributes configurationManagerAttributes = val.GetConfigurationManagerAttributes();
					if (configurationManagerAttributes != null && configurationManagerAttributes.IsAdminOnly)
					{
						string item = TomlTypeConverter.ConvertToString(val.BoxedValue, val.SettingType);
						Tuple<string, string, string, string> item2 = new Tuple<string, string, string, string>(fileIdentifier, key.Section, key.Key, item);
						hashSet.Add(item2);
					}
					InputUtils.SetInputButtons(val);
				}
			}
			hashSet = new HashSet<Tuple<string, string, string, string>>(hashSet.Where((Tuple<string, string, string, string> x) => !CachedConfigValues.Contains(x)));
			if (hashSet.Count <= 0)
			{
				return;
			}
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				ZPackage package = GenerateConfigZPackage(initial: false, hashSet.ToList());
				if (ZNet.instance.IsClientInstance())
				{
					InvokeOnSyncingConfiguration();
					ConfigRPC.SendPackage(ZRoutedRpc.instance.GetServerPeerID(), package);
					HashSet<string> hashSet2 = new HashSet<string>();
					foreach (Tuple<string, string, string, string> item3 in hashSet)
					{
						if (GetPluginGUID(item3.Item1, out var pluginGUID))
						{
							hashSet2.Add(pluginGUID);
						}
					}
					InvokeOnConfigurationSynchronized(initial: false, hashSet2);
				}
				else
				{
					ConfigRPC.SendPackage(ZNet.instance.m_peers, package);
				}
			}
			CacheConfigurationValues();
		}

		private void SetToDefaultConfigEntries()
		{
			foreach (ConfigFile configFile in GetConfigFiles())
			{
				if (!ShouldManageConfig(configFile))
				{
					continue;
				}
				foreach (ConfigDefinition key in configFile.Keys)
				{
					ConfigEntryBase val = configFile[key.Section, key.Key];
					ConfigurationManagerAttributes configurationManagerAttributes = val.GetConfigurationManagerAttributes();
					if (configurationManagerAttributes != null && configurationManagerAttributes.IsAdminOnly)
					{
						val.BoxedValue = val.DefaultValue;
					}
				}
			}
		}

		private IEnumerator ConfigRPC_OnClientReceive(long sender, ZPackage package)
		{
			InvokeOnSyncingConfiguration();
			package.ReadByte();
			package.SetPos(0);
			ApplyConfigZPackage(package, out var initial, out var pluginGUIDs);
			InvokeOnConfigurationSynchronized(initial, pluginGUIDs);
			yield break;
		}

		private IEnumerator ConfigRPC_OnServerReceive(long sender, ZPackage package)
		{
			if (ZNet.instance.IsAdmin(sender))
			{
				Logger.LogInfo($"Received configuration data from client {sender}");
				InvokeOnSyncingConfiguration();
				ApplyConfigZPackage(package, out var initial, out var pluginGUIDs);
				InvokeOnConfigurationSynchronized(initial, pluginGUIDs);
				ConfigRPC.SendPackage(ZNet.instance.m_peers.Where((ZNetPeer x) => x.m_uid != sender).ToList(), package);
			}
			yield break;
		}

		private void InvokeOnConfigurationSynchronized(bool initial, HashSet<string> pluginGUIDs)
		{
			SynchronizationManager.OnConfigurationSynchronized?.SafeInvoke(this, new ConfigurationSynchronizationEventArgs
			{
				InitialSynchronization = initial,
				UpdatedPluginGUIDs = pluginGUIDs
			});
		}

		private void InvokeOnSyncingConfiguration()
		{
			SynchronizationManager.OnSyncingConfiguration?.SafeInvoke(this, new SyncingConfigurationEventArgs());
		}

		private void ApplyConfigZPackage(ZPackage configPkg, out bool initial, out HashSet<string> pluginGUIDs)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			initial = (configPkg.ReadByte() & 0x40) != 0;
			pluginGUIDs = new HashSet<string>();
			Logger.LogDebug("Applying" + (initial ? " initial" : null) + " configuration data package");
			int num = configPkg.ReadInt();
			if (num == 0)
			{
				return;
			}
			while (num > 0)
			{
				string text = configPkg.ReadString();
				string text2 = configPkg.ReadString();
				string text3 = configPkg.ReadString();
				string text4 = configPkg.ReadString();
				if (GetPluginGUID(text, out var pluginGUID))
				{
					pluginGUIDs.Add(pluginGUID);
				}
				ConfigFile configFile = GetConfigFile(text);
				if (configFile != null)
				{
					if (configFile.Keys.Contains(new ConfigDefinition(text2, text3)))
					{
						ConfigEntryBase val = configFile[text2, text3];
						if (val.IsSyncable())
						{
							val.BoxedValue = TomlTypeConverter.ConvertToValue(text4, val.SettingType);
							InputUtils.SetInputButtons(val);
						}
						else
						{
							Logger.LogWarning("Setting for Identifier: " + text + ", Section " + text2 + ", Key " + text3 + " is not syncable");
						}
					}
					else
					{
						Logger.LogWarning("Did not find Value for Identifier: " + text + ", Section " + text2 + ", Key " + text3);
					}
				}
				else if (modNotLoadedConfigsWarnings.Add(text))
				{
					Logger.LogWarning("No config file with Identifier " + text + " is loaded, cannot apply synced values");
				}
				num--;
			}
			CacheConfigurationValues();
		}

		private ZPackage GenerateConfigZPackage(bool initial, List<Tuple<string, string, string, string>> values)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((byte)(initial ? 64 : 0));
			int count = values.Count;
			val.Write(count);
			foreach (Tuple<string, string, string, string> value in values)
			{
				val.Write(value.Item1);
				val.Write(value.Item2);
				val.Write(value.Item3);
				val.Write(value.Item4);
			}
			return val;
		}

		private bool Socket_VersionMatch(ISocket __instance)
		{
			string endPointString = __instance.GetEndPointString();
			if (string.IsNullOrEmpty(endPointString) || !socketBuffers.TryGetValue(endPointString, out var value) || value.finished)
			{
				return true;
			}
			value.versionMatchPackageIndex = value.packages.Count;
			return false;
		}

		private bool Socket_Send(ISocket __instance, ZPackage pkg)
		{
			string endPointString = __instance.GetEndPointString();
			if (string.IsNullOrEmpty(endPointString) || !socketBuffers.TryGetValue(endPointString, out var value) || value.finished)
			{
				return true;
			}
			int methodHash = GetMethodHash(pkg);
			if (methodHash == StringExtensionMethods.GetStableHashCode("PeerInfo") || methodHash == StringExtensionMethods.GetStableHashCode("RoutedRPC") || methodHash == StringExtensionMethods.GetStableHashCode("ZDOData"))
			{
				value.packages.Add(CopyZPackage(pkg));
				return false;
			}
			return true;
		}

		internal static int GetMethodHash(ZPackage pkg)
		{
			int pos = pkg.GetPos();
			pkg.SetPos(0);
			int result = pkg.ReadInt();
			pkg.SetPos(pos);
			return result;
		}

		internal static ZPackage CopyZPackage(ZPackage pkg)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			ZPackage val = new ZPackage(pkg.GetArray());
			val.SetPos(pkg.GetPos());
			return val;
		}
	}
	public class UndoManager : IManager
	{
		public interface IUndoAction
		{
			string Description();

			void Undo();

			void Redo();

			string UndoMessage();

			string RedoMessage();
		}

		private static class Patches
		{
			[HarmonyPatch(typeof(ZNetScene), "Awake")]
			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void ClearUndoQueuesBefore(ZNetScene __instance)
			{
				foreach (UndoQueue value in Instance.Queues.Values)
				{
					value.Reset();
				}
			}

			[HarmonyPatch(typeof(ZNetScene), "Shutdown")]
			[HarmonyPostfix]
			[HarmonyPriority(0)]
			private static void ClearUndoQueuesAfter(ZNetScene __instance)
			{
				foreach (UndoQueue value in Instance.Queues.Values)
				{
					value.Reset();
				}
			}
		}

		public class UndoQueue
		{
			private readonly string Name;

			private readonly int MaxSteps;

			private List<IUndoAction> History = new List<IUndoAction>();

			private int Index = -1;

			private bool Executing;

			internal UndoQueue(string name)
			{
				Name = name;
				MaxSteps = 50;
			}

			internal UndoQueue(string name, int maxSteps)
			{
				if (maxSteps <= 0 || maxSteps >= 100)
				{
					throw new ArgumentOutOfRangeException("maxSteps");
				}
				Name = name;
				MaxSteps = maxSteps;
			}

			public void Add(IUndoAction action)
			{
				if (!Executing)
				{
					if (History.Count > MaxSteps - 1)
					{
						History = History.Skip(History.Count - MaxSteps + 1).ToList();
					}
					if (Index < History.Count - 1)
					{
						History = History.Take(Index + 1).ToList();
					}
					History.Add(action);
					Index = History.Count - 1;
				}
			}

			public bool Undo()
			{
				if (Index < 0)
				{
					AddMessage("Nothing to undo.");
					return false;
				}
				bool result = true;
				Executing = true;
				try
				{
					History[Index].Undo();
					AddMessage(History[Index].UndoMessage());
				}
				catch (Exception arg)
				{
					Logger.LogWarning($"Exception thrown at index {Index} in queue {Name}:\n{arg}");
					result = false;
				}
				Index--;
				Executing = false;
				return result;
			}

			public bool Redo()
			{
				if (Index < History.Count - 1)
				{
					bool result = true;
					Executing = true;
					Index++;
					try
					{
						History[Index].Redo();
						AddMessage(History[Index].RedoMessage());
					}
					catch (Exception arg)
					{
						Logger.LogWarning($"Exception thrown at index {Index} in queue {Name}:\n{arg}");
						result = false;
					}
					Executing = false;
					return result;
				}
				AddMessage("Nothing to redo.");
				return false;
			}

			public void Reset()
			{
				History.Clear();
				Index = -1;
				Executing = false;
			}

			public int GetIndex()
			{
				return Index;
			}

			public string[] GetHistory()
			{
				return History.Select((IUndoAction x) => x.Description()).ToArray();
			}

			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Queue \"" + Name + "\"");
				if (Index < 0)
				{
					stringBuilder.AppendLine("Empty!");
				}
				else
				{
					int num = 0;
					foreach (IUndoAction item in History)
					{
						stringBuilder.AppendLine(string.Format("[{0:00}{1}] {2}", num, (Index == num) ? "*" : " ", item.Description()));
						num++;
					}
				}
				return stringBuilder.ToString();
			}
		}

		private static UndoManager _instance;

		private readonly Dictionary<string, UndoQueue> Queues = new Dictionary<string, UndoQueue>();

		public static UndoManager Instance => _instance ?? (_instance = new UndoManager());

		private UndoManager()
		{
		}

		static UndoManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			Main.LogInit("UndoManager");
			Main.Harmony.PatchAll(typeof(Patches));
		}

		private static void AddMessage(string message, bool priority = true)
		{
			if (Console.IsVisible())
			{
				((Terminal)Console.instance).AddString(message);
			}
			MessageHud instance = MessageHud.instance;
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) && !Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			if (priority)
			{
				MsgData[] array = instance.m_msgQeue.ToArray();
				instance.m_msgQeue.Clear();
				((Character)localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
				MsgData[] array2 = array;
				foreach (MsgData item in array2)
				{
					instance.m_msgQeue.Enqueue(item);
				}
				instance.m_msgQueueTimer = 10f;
			}
			else
			{
				((Character)localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
			}
		}

		public UndoQueue CreateQueue(string queueName, int maxSteps = 50)
		{
			if (!Queues.TryGetValue(queueName, out var value))
			{
				value = new UndoQueue(queueName, maxSteps);
				Queues.Add(queueName, value);
			}
			return value;
		}

		public List<string> GetQueueNames()
		{
			return Queues.Keys.OrderBy((string x) => x).ToList();
		}

		public UndoQueue GetQueue(string queueName)
		{
			if (!Queues.TryGetValue(queueName, out var value))
			{
				value = new UndoQueue(queueName);
				Queues.Add(queueName, value);
			}
			return value;
		}

		public void Add(string queueName, IUndoAction action)
		{
			GetQueue(queueName).Add(action);
		}

		public bool Undo(string queueName)
		{
			return GetQueue(queueName).Undo();
		}

		public bool Redo(string queueName)
		{
			return GetQueue(queueName).Redo();
		}
	}
	public class ZoneManager : IManager
	{
		private static class Patches
		{
			[HarmonyPatch(typeof(ZoneSystem), "SetupLocations")]
			[HarmonyPostfix]
			private static void ZoneSystem_SetupLocations(ZoneSystem __instance)
			{
				Instance.RegisterLocations(__instance);
				Instance.RegisterVegetation(__instance);
			}

			[HarmonyPatch(typeof(ClutterSystem), "Awake")]
			[HarmonyPostfix]
			private static void ClutterSystem_Awake(ClutterSystem __instance)
			{
				Instance.ClutterSystem_Awake(__instance);
			}
		}

		private static ZoneManager _instance;

		internal GameObject LocationContainer;

		public static ZoneManager Instance => _instance ?? (_instance = new ZoneManager());

		internal Dictionary<string, CustomLocation> Locations { get; } = new Dictionary<string, CustomLocation>();

		internal Dictionary<string, CustomVegetation> Vegetations { get; } = new Dictionary<string, CustomVegetation>();

		internal Dictionary<string, CustomClutter> Clutter { get; } = new Dictionary<string, CustomClutter>();

		public static event Action OnVanillaLocationsAvailable;

		public static event Action OnLocationsRegistered;

		public static event Action OnVanillaClutterAvailable;

		public static event Action OnClutterRegistered;

		public static event Action OnVanillaVegetationAvailable;

		public static event Action OnVegetationRegistered;

		private ZoneManager()
		{
		}

		static ZoneManager()
		{
			((IManager)Instance).Init();
		}

		void IManager.Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Main.LogInit("ZoneManager");
			LocationContainer = new GameObject("Locations");
			LocationContainer.transform.parent = Main.RootObject.transform;
			LocationContainer.SetActive(false);
			Main.Harmony.PatchAll(typeof(Patches));
			PrefabManager.Instance.Activate();
		}

		public static Biome AnyBiomeOf(params Biome[] biomes)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Biome val = (Biome)0;
			foreach (Biome val2 in biomes)
			{
				val |= val2;
			}
			return val;
		}

		public static List<Biome> GetMatchingBiomes(Biome biome)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			List<Biome> list = new List<Biome>();
			foreach (Biome value in Enum.GetValues(typeof(Biome)))
			{
				if ((biome & value) != 0)
				{
					list.Add(value);
				}
			}
			return list;
		}

		public GameObject CreateLocationContainer(string name)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			GameObject val = new GameObject
			{
				name = name
			};
			val.transform.SetParent(LocationContainer.transform);
			return val;
		}

		public GameObject CreateLocationContainer(GameObject gameObject)
		{
			GameObject val = Object.Instantiate<GameObject>(gameObject, LocationContainer.transform);
			((Object)val).name = ((Object)gameObject).name;
			return val;
		}

		public GameObject CreateLocationContainer(AssetBundle assetBundle, string assetName)
		{
			PluginInfo pluginInfoFromAssembly = BepInExUtils.GetPluginInfoFromAssembly(Assembly.GetCallingAssembly());
			BepInPlugin val = ((pluginInfoFromAssembly != null) ? pluginInfoFromAssembly.Metadata : null);
			if (val == null || val.GUID == ((BaseUnityPlugin)Main.Instance).Info.Metadata.GUID)
			{
				val = BepInExUtils.GetSourceModMetadata();
			}
			if (!AssetUtils.TryLoadPrefab(val, assetBundle, assetName, out var prefab))
			{
				Logger.LogError(val, "Failed to create location container for '" + assetName + "'");
				return null;
			}
			return CreateLocationContainer(prefab);
		}

		[Obsolete("Use CreateLocationContainer(GameObject) instead and define if references should be fixed in CustomLocation")]
		public GameObject CreateLocationContainer(GameObject gameObject, bool fixLocationReferences = false)
		{
			GameObject val = Object.Instantiate<GameObject>(gameObject, LocationContainer.transform);
			((Object)val).name = ((Object)gameObject).name;
			if (fixLocationReferences)
			{
				val.FixReferences(recursive: true);
			}
			return val;
		}

		public bool AddCustomLocation(CustomLocation customLocation)
		{
			if (Locations.ContainsKey(customLocation.Name))
			{
				Logger.LogWarning(customLocation.SourceMod, "Location " + customLocation.Name + " already exists");
				return false;
			}
			if (!customLocation.SoftReference)
			{
				customLocation.Prefab.SetActive(true);
			}
			Locations.Add(customLocation.Name, customLocation);
			return true;
		}

		public CustomLocation GetCustomLocation(string name)
		{
			return Locations[name];
		}

		public ZoneLocation GetZoneLocation(string name)
		{
			if (Locations.TryGetValue(name, out var value))
			{
				return value.ZoneLocation;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (Object.op_Implicit((Object)(object)ZoneSystem.instance) && ZoneSystem.instance.m_locationsByHash.TryGetValue(stableHashCode, out var value2))
			{
				return value2;
			}
			return null;
		}

		public CustomLocation CreateClonedLocation(string name, string baseName)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ZoneLocation zoneLocation = GetZoneLocation(baseName);
			zoneLocation.m_prefab.Load();
			GameObject exteriorPrefab = AssetManager.Instance.ClonePrefab(zoneLocation.m_prefab.Asset, name, LocationContainer.transform);
			CustomLocation customLocation = new CustomLocation(exteriorPrefab, fixReference: false, new LocationConfig(zoneLocation));
			AddCustomLocation(customLocation);
			zoneLocation.m_prefab.Release();
			return customLocation;
		}

		public bool RemoveCustomLocation(string name)
		{
			return Locations.Remove(name);
		}

		public bool DestroyCustomLocation(string name)
		{
			if (!Locations.TryGetValue(name, out var value))
			{
				return false;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (Object.op_Implicit((Object)(object)ZoneSystem.instance) && ZoneSystem.instance.m_locationsByHash.TryGetValue(stableHashCode, out var value2))
			{
				ZoneSystem.instance.m_locationsByHash.Remove(stableHashCode);
				ZoneSystem.instance.m_locations.Remove(value2);
			}
			if (Object.op_Implicit((Object)(object)value.Prefab))
			{
				Object.Destroy((Object)(object)value.Prefab);
			}
			return Locations.Remove(name);
		}

		public bool AddCustomVegetation(CustomVegetation customVegetation)
		{
			if (!customVegetation.IsValid())
			{
				return false;
			}
			if (!PrefabManager.Instance.AddPrefab(customVegetation.Prefab, customVegetation.SourceMod))
			{
				return false;
			}
			Vegetations.Add(customVegetation.Name, customVegetation);
			return true;
		}

		public ZoneVegetation GetZoneVegetation(string name)
		{
			if (Vegetations.TryGetValue(name, out var value))
			{
				return value.Vegetation;
			}
			return ZoneSystem.instance.m_vegetation.DefaultIfEmpty(null).FirstOrDefault((Func<ZoneVegetation, bool>)((ZoneVegetation zv) => Object.op_Implicit((Object)(object)zv.m_prefab) && ((Object)zv.m_prefab).name == name));
		}

		public bool RemoveCustomVegetation(string name)
		{
			return Vegetations.Remove(name);
		}

		public bool AddCustomClutter(CustomClutter customClutter)
		{
			if (!customClutter.IsValid())
			{
				Logger.LogWarning(customClutter.SourceMod, $"Custom clutter '{customClutter}' is not valid");
				return false;
			}
			if (Clutter.ContainsKey(customClutter.Name))
			{
				return false;
			}
			Clutter.Add(customClutter.Name, customClutter);
			return true;
		}

		public Clutter GetClutter(string name)
		{
			if (Clutter.TryGetValue(name, out var value))
			{
				return value.Clutter;
			}
			if (!Object.op_Implicit((Object)(object)ClutterSystem.instance))
			{
				return null;
			}
			return ClutterSystem.instance.m_clutter.DefaultIfEmpty(null).FirstOrDefault((Func<Clutter, bool>)((Clutter zv) => zv?.m_name == name));
		}

		public bool RemoveCustomClutter(string name)
		{
			return Clutter.Remove(name);
		}

		private void ClutterSystem_Awake(ClutterSystem instance)
		{
			InvokeOnVanillaClutterAvailable();
			if (Clutter.Count > 0)
			{
				Logger.LogInfo($"Injecting {Clutter.Count} custom clutter");
				List<string> list = new List<string>();
				foreach (CustomClutter value in Clutter.Values)
				{
					try
					{
						if (value.FixReference)
						{
							value.Prefab.FixReferences(recursive: true);
							value.FixReference = false;
						}
						instance.m_clutter.Add(value.Clutter);
					}
					catch (Exception arg)
					{
						Logger.LogWarning(value?.SourceMod, $"Exception caught while adding clutter: {arg}");
						list.Add(value.Name);
					}
				}
				foreach (string item in list)
				{
					Clutter.Remove(item);
				}
			}
			InvokeOnClutterRegistered();
		}

		private void RegisterLocations(ZoneSystem self)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			InvokeOnVanillaLocationsAvailable();
			if (Locations.Count > 0)
			{
				List<string> list = new List<string>();
				Logger.LogInfo($"Injecting {Locations.Count} custom locations");
				foreach (CustomLocation value in Locations.Values)
				{
					try
					{
						Logger.LogDebug(string.Format("Adding custom location {0} in {1}", value, string.Join(", ", GetMatchingBiomes(value.ZoneLocation.m_biome))));
						if (value.FixReference && !value.SoftReference)
						{
							value.Prefab.FixReferences(recursive: true);
							value.FixReference = false;
						}
						if (!value.SoftReference)
						{
							PrepareLocation(value.ZoneLocation, value.SourceMod);
						}
						RegisterLocationInZoneSystem(self, value.ZoneLocation);
					}
					catch (Exception arg)
					{
						Logger.LogWarning(value?.SourceMod, $"Exception caught while adding location: {arg}");
						list.Add(value?.Name);
					}
				}
				foreach (string item in list)
				{
					Locations.Remove(item);
				}
			}
			InvokeOnLocationsRegistered();
		}

		private void RegisterVegetation(ZoneSystem self)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			InvokeOnVanillaVegetationAvailable();
			if (Vegetations.Count > 0)
			{
				List<string> list = new List<string>();
				Logger.LogInfo($"Injecting {Vegetations.Count} custom vegetation");
				foreach (CustomVegetation value in Vegetations.Values)
				{
					try
					{
						Logger.LogDebug(string.Format("Adding custom vegetation {0} in {1}", value, string.Join(", ", GetMatchingBiomes(value.Vegetation.m_biome))));
						if (value.FixReference)
						{
							value.Prefab.FixReferences(recursive: true);
							value.FixReference = false;
						}
						self.m_vegetation.Add(value.Vegetation);
					}
					catch (Exception arg)
					{
						Logger.LogWarning(value?.SourceMod, $"Exception caught while adding vegetation: {arg}");
						list.Add(value.Name);
					}
				}
				foreach (string item in list)
				{
					Vegetations.Remove(item);
				}
			}
			InvokeOnVegetationRegistered();
		}

		public void RegisterLocationInZoneSystem(ZoneLocation zoneLocation)
		{
			PrepareLocation(zoneLocation, BepInExUtils.GetSourceModMetadata());
			RegisterLocationInZoneSystem(ZoneSystem.instance, zoneLocation);
		}

		internal void PrepareLocation(ZoneLocation zoneLocation, BepInPlugin sourceMod)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			zoneLocation.m_prefab.Load();
			ZNetView[] enabledComponentsInChildren = Utils.GetEnabledComponentsInChildren<ZNetView>(zoneLocation.m_prefab.Asset);
			foreach (ZNetView znet in enabledComponentsInChildren)
			{
				RegisterUnknownPrefab(sourceMod, znet);
			}
			RandomSpawn[] enabledComponentsInChildren2 = Utils.GetEnabledComponentsInChildren<RandomSpawn>(zoneLocation.m_prefab.Asset);
			RandomSpawn[] array = enabledComponentsInChildren2;
			foreach (RandomSpawn val in array)
			{
				val.Prepare();
			}
			foreach (ZNetView item in enabledComponentsInChildren2.SelectMany((RandomSpawn x) => x.m_childNetViews))
			{
				RegisterUnknownPrefab(sourceMod, item);
			}
		}

		private static void RegisterUnknownPrefab(BepInPlugin sourceMod, ZNetView znet)
		{
			string prefabName = znet.GetPrefabName();
			if (!prefabName.StartsWith("JVLmock_") && !ZNetScene.instance.m_namedPrefabs.ContainsKey(StringExtensionMethods.GetStableHashCode(prefabName)))
			{
				GameObject val = Object.Instantiate<GameObject>(((Component)znet).gameObject, PrefabManager.Instance.PrefabContainer.transform);
				((Object)val).name = prefabName;
				CustomPrefab customPrefab = new CustomPrefab(val, sourceMod);
				PrefabManager.Instance.AddPrefab(customPrefab);
				PrefabManager.Instance.RegisterToZNetScene(customPrefab.Prefab);
			}
		}

		private void RegisterLocationInZoneSystem(ZoneSystem zoneSystem, ZoneLocation zoneLocation)
		{
			if (!zoneSystem.m_locationsByHash.ContainsKey(zoneLocation.Hash))
			{
				zoneSystem.m_locationsByHash.Add(zoneLocation.Hash, zoneLocation);
				zoneSystem.m_locations.Add(zoneLocation);
			}
			if (zoneLocation.m_prefab.IsLoaded)
			{
				zoneLocation.m_prefab.Release();
			}
		}

		private static void InvokeOnVanillaLocationsAvailable()
		{
			ZoneManager.OnVanillaLocationsAvailable?.SafeInvoke();
		}

		private static void InvokeOnLocationsRegistered()
		{
			ZoneManager.OnLocationsRegistered?.SafeInvoke();
		}

		private static void InvokeOnVanillaVegetationAvailable()
		{
			ZoneManager.OnVanillaVegetationAvailable?.SafeInvoke();
		}

		private static void InvokeOnVegetationRegistered()
		{
			ZoneManager.OnVegetationRegistered?.SafeInvoke();
		}

		private static void InvokeOnVanillaClutterAvailable()
		{
			ZoneManager.OnVanillaClutterAvailable?.SafeInvoke();
		}

		private static void InvokeOnClutterRegistered()
		{
			ZoneManager.OnClutterRegistered?.SafeInvoke();
		}
	}
}
namespace Jotunn.Extensions
{
	public static class ConfigFileExtensions
	{
		internal class ConfigFileOrderingMaps
		{
			public Dictionary<string, int> sectionToSectionNumber = new Dictionary<string, int>();

			public Dictionary<string, int> sectionToSettingOrder = new Dictionary<string, int>();
		}

		private static readonly Dictionary<string, ConfigFileOrderingMaps> _configFileOrderingMaps = new Dictionary<string, ConfigFileOrderingMaps>();

		private static string GetOrderedSectionName(this ConfigFile configFile, string section)
		{
			if (!_configFileOrderingMaps.TryGetValue(configFile.ConfigFilePath, out var value))
			{
				value = new ConfigFileOrderingMaps();
				_configFileOrderingMaps.Add(configFile.ConfigFilePath, value);
			}
			if (!value.sectionToSectionNumber.TryGetValue(section, out var value2))
			{
				value2 = value.sectionToSectionNumber.Count + 1;
				value.sectionToSectionNumber[section] = value2;
			}
			return $"{value2} - {section}";
		}

		private static int GetSettingOrder(this ConfigFile configFile, string section)
		{
			if (!_configFileOrderingMaps.TryGetValue(configFile.ConfigFilePath, out var value))
			{
				value = new ConfigFileOrderingMaps();
				_configFileOrderingMaps.Add(configFile.ConfigFilePath, value);
			}
			if (!value.sectionToSettingOrder.TryGetValue(section, out var value2))
			{
				value2 = 0;
			}
			value.sectionToSettingOrder[section] = value2 - 1;
			return value2;
		}

		internal static string GetExtendedDescription(string description, bool synchronizedSetting)
		{
			return description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]");
		}

		public static ConfigEntry<T> BindConfigInOrder<T>(this ConfigFile configFile, string section, string key, T defaultValue, string description, bool synced = true, bool sectionOrder = true, bool settingOrder = true, AcceptableValueBase acceptableValues = null, Action<ConfigEntryBase> customDrawer = null, ConfigurationManagerAttributes configAttributes = null)
		{
			section = (sectionOrder ? configFile.GetOrderedSectionName(section) : section);
			int value = (settingOrder ? configFile.GetSettingOrder(section) : 0);
			return configFile.BindConfig(section, key, defaultValue, description, synced, value, acceptableValues, customDrawer, configAttributes);
		}

		public static ConfigEntry<T> BindConfig<T>(this ConfigFile configFile, string section, string key, T defaultValue, string description, bool synced = true, int? order = null, AcceptableValueBase acceptableValues = null, Action<ConfigEntryBase> customDrawer = null, ConfigurationManagerAttributes configAttributes = null)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			string extendedDescription = GetExtendedDescription(description, synced);
			if (configAttributes == null)
			{
				configAttributes = new ConfigurationManagerAttributes();
			}
			configAttributes.IsAdminOnly = synced;
			configAttributes.Order = order;
			configAttributes.CustomDrawer = customDrawer;
			return configFile.Bind<T>(section, key, defaultValue, new ConfigDescription(extendedDescription, acceptableValues, new object[1] { configAttributes }));
		}

		public static bool SetSaveOnConfigSet(this ConfigFile configFile, bool saveOnConfigSet)
		{
			bool saveOnConfigSet2 = configFile.SaveOnConfigSet;
			configFile.SaveOnConfigSet = saveOnConfigSet;
			return saveOnConfigSet2;
		}
	}
	internal static class PluginExtensions
	{
		internal static NetworkCompatibilityAttribute GetNetworkCompatibilityAttribute(this BaseUnityPlugin plugin)
		{
			return ((object)plugin).GetType().GetCustomAttributes(typeof(NetworkCompatibilityAttribute), inherit: true).Cast<NetworkCompatibilityAttribute>()
				.FirstOrDefault();
		}

		internal static SynchronizationModeAttribute GetSynchronizationModeAttribute(this BaseUnityPlugin plugin)
		{
			return ((object)plugin).GetType().GetCustomAttributes(typeof(SynchronizationModeAttribute), inherit: true).Cast<SynchronizationModeAttribute>()
				.FirstOrDefault();
		}
	}
	public static class StringExtensions
	{
		public static bool ContainsAny(this string str, params string[] substrings)
		{
			foreach (string value in substrings)
			{
				if (str.Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		public static bool EndsWithAny(this string str, params string[] suffixes)
		{
			foreach (string value in suffixes)
			{
				if (str.EndsWith(value))
				{
					return true;
				}
			}
			return false;
		}

		public static bool StartsWithAny(this string str, params string[] prefixes)
		{
			foreach (string value in prefixes)
			{
				if (str.StartsWith(value))
				{
					return true;
				}
			}
			return false;
		}

		public static string RemoveSuffix(this string s, string suffix)
		{
			if (s.EndsWith(suffix))
			{
				return s.Substring(0, s.Length - suffix.Length);
			}
			return s;
		}

		public static string RemovePrefix(this string s, string prefix)
		{
			if (s.StartsWith(prefix))
			{
				return s.Substring(prefix.Length, s.Length - prefix.Length);
			}
			return s;
		}

		public static string CapitalizeFirstLetter(this string s)
		{
			if (s.Length == 0)
			{
				return s;
			}
			if (s.Length == 1)
			{
				return $"{char.ToUpper(s[0])}";
			}
			return char.ToUpper(s[0]) + s.Substring(1);
		}
	}
	public static class TransformExtensions
	{
		public static Transform FindDeepChild(this Transform transform, string childName, IterativeSearchType searchType = (IterativeSearchType)1)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return Utils.FindChild(transform, childName, searchType);
		}
	}
}
namespace Jotunn.Entities
{
	public abstract class ConsoleCommand : CustomEntity
	{
		public abstract string Name { get; }

		public abstract string Help { get; }

		public virtual bool IsCheat => false;

		public virtual bool IsNetwork => false;

		public virtual bool OnlyServer => false;

		public virtual bool IsSecret => false;

		public virtual void Run(string[] args)
		{
		}

		public virtual void Run(string[] args, Terminal context)
		{
			Run(args);
		}

		public virtual List<string> CommandOptionList()
		{
			return null;
		}

		public override string ToString()
		{
			return Name.ToLower();
		}
	}
	public class CustomClutter : CustomEntity
	{
		public GameObject Prefab { get; }

		public Clutter Clutter { get; }

		public string Name { get; }

		public bool FixReference { get; set; }

		public CustomClutter(GameObject prefab, bool fixReference, ClutterConfig config)
			: base(Assembly.GetCallingAssembly())
		{
			Prefab = prefab;
			Name = ((Object)prefab).name;
			Clutter = config.ToClutter();
			Clutter.m_prefab = prefab;
			FixReference = fixReference;
		}

		public CustomClutter(AssetBundle assetBundle, string assetName, bool fixReference, ClutterConfig config)
			: base(Assembly.GetCallingAssembly())
		{
			Name = assetName;
			if (AssetUtils.TryLoadPrefab(base.SourceMod, assetBundle, assetName, out var prefab))
			{
				Prefab = prefab;
				Clutter = config.ToClutter();
				Clutter.m_prefab = Prefab;
				FixReference = fixReference;
			}
		}

		public bool IsValid()
		{
			bool result = true;
			if (!Object.op_Implicit((Object)(object)Prefab))
			{
				Logger.LogError(base.SourceMod, $"Custom Clutter '{this}' has no prefab");
				result = false;
			}
			return result;
		}

		public override string ToString()
		{
			return Name;
		}
	}
	public class CustomCreature : CustomEntity
	{
		private string fallbackCreatureName;

		public GameObject Prefab { get; }

		public List<SpawnData> Spawns { get; } = new List<SpawnData>();

		public bool FixReference { get; set; }

		internal bool FixConfig { get; set; }

		internal bool UseCumulativeLevelEffects { get; set; }

		private string CreatureName
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)Prefab))
				{
					return fallbackCreatureName;
				}
				return ((Object)Prefab).name;
			}
		}

		public CustomCreature(GameObject creaturePrefab, bool fixReference)
			: base(Assembly.GetCallingAssembly())
		{
			Prefab = creaturePrefab;
			FixReference = fixReference;
		}

		public CustomCreature(GameObject creaturePrefab, bool fixReference, CreatureConfig creatureConfig)
			: base(Assembly.GetCallingAssembly())
		{
			Prefab = creaturePrefab;
			ApplyCreatureConfig(creatureConfig);
			FixReference = fixReference;
		}

		public CustomCreature(string name, string basePrefabName, CreatureConfig creatureConfig)
			: base(Assembly.GetCallingAssembly())
		{
			GameObject creaturePrefab = CreatureManager.Instance.GetCreaturePrefab(basePrefabName);
			if (Object.op_Implicit((Object)(object)creaturePrefab))
			{
				Prefab = PrefabManager.Instance.CreateClonedPrefab(name, creaturePrefab);
				creatureConfig.Name = name;
				ApplyCreatureConfig(creatureConfig);
			}
		}

		public CustomCreature(AssetBundle assetBundle, string assetName, bool fixReference, CreatureConfig creatureConfig)
			: base(Assembly.GetCallingAssembly())
		{
			fallbackCreatureName = assetName;
			if (AssetUtils.TryLoadPrefab(base.SourceMod, assetBundle, assetName, out var prefab))
			{
				Prefab = prefab;
				ApplyCreatureConfig(creatureConfig);
				FixReference = fixReference;
			}
		}

		public bool IsValid()
		{
			bool result = true;
			if (!Object.op_Implicit((Object)(object)Prefab))
			{
				Logger.LogError(base.SourceMod, $"CustomCreature '{this}' has no prefab");
				result = false;
			}
			Type[] array = new Type[5]
			{
				typeof(Character),
				typeof(BaseAI),
				typeof(CapsuleCollider),
				typeof(Rigidbody),
				typeof(ZSyncAnimation)
			};
			Type[] array2 = array;
			foreach (Type type in array2)
			{
				if (Object.op_Implicit((Object)(object)Prefab) && !Object.op_Implicit((Object)(object)Prefab.GetComponent(type)))
				{
					Logger.LogError(base.SourceMod, $"CustomCreature '{this}' has no {type} component");
					result = false;
				}
			}
			if (Object.op_Implicit((Object)(object)Prefab) && !Object.op_Implicit((Object)(object)Prefab.GetComponentInChildren<Animator>()))
			{
				Logger.LogError(base.SourceMod, $"CustomCreature '{this}' has no Animator component");
				result = false;
			}
			if (Object.op_Implicit((Object)(object)Prefab) && !Object.op_Implicit((Object)(object)Prefab.GetComponentInChildren<CharacterAnimEvent>()))
			{
				Logger.LogError(base.SourceMod, $"CustomCreature '{this}' has no CharacterAnimEvent component");
				result = false;
			}
			return result;
		}

		public static bool IsCustomCreature(string prefabName)
		{
			return CreatureManager.Instance.Creatures.Any((CustomCreature x) => ((Object)x.Prefab).name == prefabName);
		}

		public override bool Equals(object obj)
		{
			return obj.GetHashCode() == GetHashCode();
		}

		public override int GetHashCode()
		{
			return StringExtensionMethods.GetStableHashCode(CreatureName);
		}

		public override string ToString()
		{
			return CreatureName;
		}

		private void ApplyCreatureConfig(CreatureConfig creatureConfig)
		{
			creatureConfig.Apply(Prefab);
			FixConfig = creatureConfig.DropConfigs.Any() || creatureConfig.Consumables.Any();
			UseCumulativeLevelEffects = creatureConfig.UseCumulativeLevelEffects;
			Spawns.AddRange(creatureConfig.GetSpawns());
			foreach (SpawnData spawn in Spawns)
			{
				spawn.m_prefab = Prefab;
			}
		}
	}
	public abstract class CustomEntity
	{
		public BepInPlugin SourceMod { get; }

		internal CustomEntity()
		{
			SourceMod = BepInExUtils.GetSourceModMetadata();
		}

		internal CustomEntity(BepInPlugin sourceMod)
		{
			SourceMod = sourceMod;
		}

		internal CustomEntity(Assembly callingAssembly)
		{
			PluginInfo pluginInfoFromAssembly = BepInExUtils.GetPluginInfoFromAssembly(callingAssembly);
			SourceMod = ((pluginInfoFromAssembly != null) ? pluginInfoFromAssembly.Metadata : null);
			if (SourceMod == null || SourceMod.GUID == ((BaseUnityPlugin)Main.Instance).Info.Metadata.GUID)
			{
				SourceMod = BepInExUtils.GetSourceModMetadata();
			}
		}
	}
	public class CustomItem : CustomEntity
	{
		private string fallbackItemName;

		public GameObject ItemPrefab { get; }

		public ItemDrop ItemDrop { get; }

		public CustomRecipe Recipe { get; set; }

		public bool FixReference { get; set; }

		internal Texture2D StyleTex { get; set; }

		internal bool FixConfig { get; set; }

		private string ItemName
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)ItemPrefab))
				{
					return fallbackItemName;
				}
				return ((Object)ItemPrefab).name;
			}
		}

		public CustomItem(GameObject itemPrefab, bool fixReference)
			: base(Assembly.GetCallingAssembly())
		{
			ItemPrefab = itemPrefab;
			ItemDrop = itemPrefab.GetComponent<ItemDrop>();
			FixReference = fixReference;
		}

		public CustomItem(GameObject itemPrefab, bool fixReference, ItemConfig itemConfig)
			: base(Assembly.GetCallingAssembly())
		{
			ItemPrefab = itemPrefab;
			ItemDrop = itemPrefab.GetComponent<ItemDrop>();
			FixReference = fixReference;
			ApplyItemConfig(itemConfig);
		}

		public CustomItem(string name, bool addZNetView)
			: base(Assembly.GetCallingAssembly())
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			ItemPrefab = PrefabManager.Instance.CreateEmptyPrefab(name, addZNetView);
			ItemDrop = ItemPrefab.AddComponent<ItemDrop>();
			ItemDrop.m_itemData.m_shared = new SharedData();
			ItemDrop.m_itemData.m_shared.m_name = name;
		}

		public CustomItem(string name, bool addZNetView, ItemConfig itemConfig)
			: base(Assembly.GetCallingAssembly())
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			ItemPrefab = PrefabManager.Instance.CreateEmptyPrefab(name, addZNetView);
			ItemDrop = ItemPrefab.AddComponent<ItemDrop>();
			ItemDrop.m_itemData.m_shared = new SharedData();
			ItemDrop.m_itemData.m_shared.m_name = name;
			ApplyItemConfig(itemConfig);
		}

		public CustomItem(string name, string basePrefabName)
			: base(Assembly.GetCallingAssembly())
		{
			GameObject val = PrefabManager.Instance.CreateClonedPrefab(name, basePrefabName);
			if (Object.op_Implicit((Object)(object)val))
			{
				ItemPrefab = val;
				ItemDrop = ItemPrefab.GetComponent<ItemDrop>();
			}
		}

		public CustomItem(string name, string basePrefabName, ItemConfig itemConfig)
			: base(Assembly.GetCallingAssembly())
		{
			GameObject val = PrefabManager.Instance.CreateClonedPrefab(name, basePrefabName);
			if (Object.op_Implicit((Object)(object)val))
			{
				ItemPrefab = val;
				ItemDrop = val.GetComponent<ItemDrop>();
				ApplyItemConfig(itemConfig);
			}
		}

		public CustomItem(AssetBundle assetBundle, string assetName, bool fixReference, ItemConfig itemConfig)
			: base(Assembly.GetCallingAssembly())
		{
			fallbackItemName = assetName;
			if (AssetUtils.TryLoadPrefab(base.SourceMod, assetBundle, assetName, out var prefab))
			{
				ItemPrefab = prefab;
				ItemDrop = ItemPrefab.GetComponent<ItemDrop>();
				FixReference = fixReference;
				ApplyItemConfig(itemConfig);
			}
		}

		public bool IsValid()
		{
			bool result = true;
			if (!Object.op_Implicit((Object)(object)ItemPrefab))
			{
				Logger.LogError(base.SourceMod, $"CustomItem '{this}' has no prefab");
				result = false;
			}
			if (Object.op_Implicit((Object)(object)ItemPrefab) && !ItemPrefab.IsValid())
			{
				result = false;
			}
			if (!Object.op_Implicit((Object)(object)ItemDrop))
			{
				Logger.LogError(base.SourceMod, $"CustomItem '{this}' has no ItemDrop component");
				result = false;
			}
			int? num = ((!Object.op_Implicit((Object)(object)ItemDrop)) ? ((int?)null) : ItemDrop.m_itemData?.m_shared?.m_icons?.Length);
			if (Recipe != null && (!num.HasValue || num == 0))
			{
				Logger.LogError(base.SourceMod, $"CustomItem '{this}' has no icon");
				result = false;
			}
			return result;
		}

		public static bool IsCustomItem(string prefabName)
		{
			return ItemManager.Instance.Items.ContainsKey(prefabName);
		}

		public override bool Equals(object obj)
		{
			return obj.GetHashCode() == GetHashCode();
		}

		public override int GetHashCode()
		{
			return StringExtensionMethods.GetStableHashCode(ItemName);
		}

		public override string ToString()
		{
			return ItemName;
		}

		internal void FixVariants()
		{
			Sprite[] array = ((!Object.op_Implicit((Object)(object)ItemDrop)) ? null : ItemDrop.m_itemData?.m_shared?.m_icons);
			if (array == null || array.Length == 0 || !Object.op_Implicit((Object)(object)StyleTex))
			{
				return;
			}
			foreach (Renderer renderer in ShaderHelper.GetRenderers(ItemPrefab))
			{
				Material[] materials = renderer.materials;
				foreach (Material val in materials)
				{
					val.shader = PrefabManager.Cache.GetPrefab<Shader>("Custom/Creature");
					if (val.HasProperty("_StyleTex"))
					{
						ItemDrop.m_itemData.m_shared.m_variants = array.Length;
						((Component)renderer).gameObject.GetOrAddComponent<ItemStyle>();
						val.EnableKeyword("_USESTYLES_ON");
						val.SetFloat("_Style", 0f);
						val.SetFloat("_UseStyles", 1f);
						val.SetTexture("_StyleTex", (Texture)(object)StyleTex);
					}
				}
			}
		}

		private void ApplyItemConfig(ItemConfig itemConfig)
		{
			itemConfig.Apply(ItemPrefab);
			FixConfig = true;
			StyleTex = itemConfig.StyleTex;
			AssignRecipeFromConfig(itemConfig);
		}

		private void AssignRecipeFromConfig(ItemConfig itemConfig)
		{
			Recipe recipe = itemConfig.GetRecipe();
			if ((Object)(object)recipe != (Object)null)
			{
				Recipe = new CustomRecipe(recipe, fixReference: true, fixRequirementReferences: true);
			}
		}
	}
	public class CustomItemConversion : CustomEntity
	{
		public enum ConversionType
		{
			CookingStation,
			Fermenter,
			Smelter,
			Incinerator
		}

		internal bool FixReference = true;

		private ItemConversion _cookingConversion;

		private ItemConversion _fermenterConversion;

		private ItemConversion _smelterConversion;

		private IncineratorConversion _incineratorConversion;

		public ConversionType Type { get; }

		public ConversionConfig Config { get; }

		internal object ItemConversion => Type switch
		{
			ConversionType.CookingStation => _cookingConversion, 
			ConversionType.Fermenter => _fermenterConversion, 
			ConversionType.Smelter => _smelterConversion, 
			ConversionType.Incinerator => _incineratorConversion, 
			_ => null, 
		};

		public CustomItemConversion(ConversionConfig config)
			: base(Assembly.GetCallingAssembly())
		{
			if (config is CookingConversionConfig cookingConversionConfig)
			{
				Type = ConversionType.CookingStation;
				_cookingConversion = cookingConversionConfig.GetItemConversion();
			}
			if (config is FermenterConversionConfig fermenterConversionConfig)
			{
				Type = ConversionType.Fermenter;
				_fermenterConversion = fermenterConversionConfig.GetItemConversion();
			}
			if (config is SmelterConversionConfig smelterConversionConfig)
			{
				Type = ConversionType.Smelter;
				_smelterConversion = smelterConversionConfig.GetItemConversion();
			}
			if (config is IncineratorConversionConfig incineratorConversionConfig)
			{
				Type = ConversionType.Incinerator;
				_incineratorConversion = incineratorConversionConfig.GetIncineratorConversion();
			}
			Config = config;
		}

		public bool IsValid()
		{
			if (Config.Station != null && Config.FromItem != null)
			{
				return Config.ToItem != null;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			return obj.GetHashCode() == GetHashCode();
		}

		public override int GetHashCode()
		{
			return StringExtensionMethods.GetStableHashCode(ToString());
		}

		public override string ToString()
		{
			return $"{Config.Station} ({Type}): {Config.FromItem} -> {Config.ToItem}";
		}
	}
	public class CustomLocalization : CustomEntity
	{
		private static HashSet<string> loggedInvalidTokens = new HashSet<string>();

		private static bool? _yamlDotNetAvailable;

		internal Dictionary<string, Dictionary<string, string>> Map { get; }

		internal static bool IsYamlDotNetAvailable()
		{
			bool valueOrDefault = _yamlDotNetAvailable == true;
			if (!_yamlDotNetAvailable.HasValue)
			{
				valueOrDefault = AppDomain.CurrentDomain.GetAssemblies().Any((Assembly a) => a.GetName().Name == "YamlDotNet");
				_yamlDotNetAvailable = valueOrDefault;
				return valueOrDefault;
			}
			return valueOrDefault;
		}

		[Obsolete("Use LocalizationManager.Instance.GetLocalization() instead")]
		public CustomLocalization()
			: base(Assembly.GetCallingAssembly())
		{
			Map = new Dictionary<string, Dictionary<string, string>>();
		}

		public CustomLocalization(BepInPlugin sourceMod)
			: base(sourceMod)
		{
			Map = new Dictionary<string, Dictionary<string, string>>();
		}

		public IEnumerable<string> GetLanguages()
		{
			return Map.Keys;
		}

		public IReadOnlyDictionary<string, string> GetTranslations(in string language)
		{
			if (!Map.TryGetValue(language, out var value))
			{
				return new Dictionary<string, string>();
			}
			return value;
		}

		public string TryTranslate(string word)
		{
			if (string.IsNullOrEmpty(word))
			{
				return string.Empty;
			}
			if (!word.StartsWith('$'.ToString()))
			{
				return word;
			}
			if (word.IndexOfAny(LocalizationManager.ForbiddenCharsArr) != -1)
			{
				if (loggedInvalidTokens.Add(word))
				{
					Logger.LogWarning(base.SourceMod, "Token '" + word + "' must not contain following chars: ' (){}[]+-!?/\\\\&%,.:-=<>\n'");
				}
				return "[" + word + "]";
			}
			string text = word.TrimStart(new char[1] { '$' });
			string playerLanguage = LocalizationManager.GetPlayerLanguage();
			string text2 = "English";
			if (Map.TryGetValue(playerLanguage, out var value) && value.TryGetValue(text, out var value2))
			{
				return value2;
			}
			if (playerLanguage != text2 && Map.TryGetValue(text2, out value) && value.TryGetValue(text, out value2))
			{
				return value2;
			}
			if (Localization.m_instance != null)
			{
				return Localization.m_instance.Translate(text);
			}
			return "[" + word + "]";
		}

		public bool Contains(in string language, in string token)
		{
			string key = token.TrimStart(new char[1] { '$' });
			if (Map.TryGetValue(language, out var value))
			{
				return value.ContainsKey(key);
			}
			return false;
		}

		public void AddTranslation(in string token, string translation)
		{
			AddTranslation("English", in token, translation);
		}

		public void AddTranslation(in string language, in string token, string translation)
		{
			if (!Map.ContainsKey(language))
			{
				Map.Add(language, new Dictionary<string, string>());
			}
			if (ValidateLanguage(in language) && ValidateToken(in token) && ValidateTranslation(in translation))
			{
				string cleanedToken = token.TrimStart(new char[1] { '$' });
				AddTranslationToMap(in language, cleanedToken, translation);
			}
		}

		public void AddTranslation(in string language, Dictionary<string, string> tokenValue)
		{
			if (!Map.ContainsKey(language))
			{
				Map.Add(language, new Dictionary<string, string>());
			}
			if (!ValidateLanguage(in language))
			{
				return;
			}
			foreach (KeyValuePair<string, string> item in tokenValue)
			{
				string token = item.Key.TrimStart(new char[1] { '$' });
				string translation = item.Value;
				if (ValidateToken(in token) && ValidateTranslation(in translation))
				{
					AddTranslationToMap(in language, token, translation);
				}
			}
		}

		public void AddFileByPath(string path, bool isJson = false)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			string text = File.ReadAllText(path);
			if (text == null)
			{
				throw new ArgumentNullException("fileContent");
			}
			string text2 = Path.GetExtension(path).ToLowerInvariant();
			string text3;
			if (text2 == ".yaml" || text2 == ".yml")
			{
				AddYamlFile(Path.GetFileName(Path.GetDirectoryName(path)), text);
				text3 = "YAML";
			}
			else if (isJson)
			{
				AddJsonFile(Path.GetFileName(Path.GetDirectoryName(path)), text);
				text3 = "JSON";
			}
			else
			{
				AddLanguageFile(text);
				text3 = "";
			}
			Logger.LogDebug("Added " + text3 + " language file: " + Path.GetFileName(path));
		}

		public void AddJsonFile(string language, string fileContent)
		{
			if (!ValidateLanguage(in language))
			{
				return;
			}
			IDictionary<string, object> dictionary;
			try
			{
				dictionary = global::SimpleJson.SimpleJson.DeserializeObject<IDictionary<string, object>>(fileContent);
			}
			catch (Exception ex)
			{
				Logger.LogWarning(base.SourceMod, "Could not read " + language + " JSON localization: " + ex.Message);
				return;
			}
			if (!Map.ContainsKey(language))
			{
				Map.Add(language, new Dictionary<string, string>());
			}
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				string translation = item.Value as string;
				string token = item.Key.TrimStart(new char[1] { '$' });
				if (ValidateToken(in token) && ValidateTranslation(in translation))
				{
					AddTranslationToMap(in language, token, translation);
				}
			}
		}

		public void AddYamlFile(string language, string fileContent)
		{
			if (!IsYamlDotNetAvailable())
			{
				Logger.LogWarning(base.SourceMod, "Cannot load YAML localization for '" + language + "': YamlDotNet is not loaded. Mods using .yaml/.yml localization must include YamlDotNet.dll as a dependency.");
			}
			else if (ValidateLanguage(in language))
			{
				ParseAndAddYaml(language, fileContent);
			}
		}

		private void ParseAndAddYaml(string language, string fileContent)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			Dictionary<string, string> dictionary;
			try
			{
				dictionary = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).IgnoreFields().Build().Deserialize<Dictionary<string, string>>(fileContent);
			}
			catch (Exception ex)
			{
				Logger.LogWarning(base.SourceMod, "Could not read " + language + " YAML localization: " + ex.Message);
				return;
			}
			if (dictionary == null)
			{
				return;
			}
			if (!Map.ContainsKey(language))
			{
				Map.Add(language, new Dictionary<string, string>());
			}
			foreach (KeyValuePair<string, string> item in dictionary)
			{
				string token = item.Key.TrimStart(new char[1] { '$' });
				if (ValidateToken(in token) && ValidateTranslation(item.Value))
				{
					AddTranslationToMap(in language, token, item.Value);
				}
			}
		}

		public void AddLanguageFile(string fileContent)
		{
			StringReader stringReader = new StringReader(fileContent);
			string[] array = stringReader.ReadLine().Split(new char[1] { ',' });
			foreach (List<string> item in LocalizationManager.DoQuoteLineSplit(stringReader))
			{
				if (item.Count == 0)
				{
					continue;
				}
				string token = item[0];
				if (token.StartsWith("//") || token.Length == 0 || !ValidateToken(in token))
				{
					continue;
				}
				string cleanedToken = token.TrimStart(new char[1] { '$' });
				for (int i = 1; i < item.Count; i++)
				{
					string language = array[i];
					string translation = item[i];
					if (string.IsNullOrEmpty(translation) || translation[0] == '\r')
					{
						translation = item[1];
					}
					if (ValidateLanguage(in language) && ValidateTranslation(in translation))
					{
						if (!Map.ContainsKey(language))
						{
							Map.Add(language, new Dictionary<string, string>());
						}
						AddTranslationToMap(in language, cleanedToken, translation);
					}
				}
			}
		}

		public void ClearToken(in string language, in string token)
		{
			if (Map.ContainsKey(language))
			{
				Map.Remove(token.TrimStart(new char[1] { '$' }));
			}
		}

		public void ClearToken(in string token)
		{
			ClearToken("English", in token);
		}

		public void ClearLanguage(in string language)
		{
			Map.Remove(language);
		}

		public void ClearAll()
		{
			Map.Clear();
		}

		private void AddTranslationToMap(in string language, string cleanedToken, string translation)
		{
			Map[language][cleanedToken] = translation;
			if (Localization.m_instance != null && !Localization.m_instance.m_translations.ContainsKey(cleanedToken))
			{
				Localization.m_instance.AddWord(cleanedToken, translation);
			}
		}

		private bool ValidateLanguage(in string language)
		{
			if (string.IsNullOrEmpty(language))
			{
				throw new ArgumentNullException("language");
			}
			if (!char.IsUpper(language[0]))
			{
				Logger.LogWarning(base.SourceMod, "Language '" + language + "' must start with a capital letter");
				return false;
			}
			return true;
		}

		private bool ValidateToken(in string token)
		{
			if (string.IsNullOrEmpty(token))
			{
				throw new ArgumentNullException("token");
			}
			if (token.IndexOfAny(LocalizationManager.ForbiddenCharsArr) != -1)
			{
				if (loggedInvalidTokens.Add(token))
				{
					Logger.LogWarning(base.SourceMod, "Token '" + token + "' must not contain following chars: ' (){}[]+-!?/\\\\&%,.:-=<>\n'");
				}
				return false;
			}
			return true;
		}

		private bool ValidateTranslation(in string translation)
		{
			if (translation == null)
			{
				throw new ArgumentNullException("translation");
			}
			return true;
		}

		public override string ToString()
		{
			return "Localization (" + base.SourceMod.GUID + ")";
		}
	}
	public class CustomLocation : CustomEntity
	{
		private readonly LocationConfig _locationConfig;

		public GameObject Prefab { get; }

		public ZoneLocation ZoneLocation { get; }

		public Location Location { get; }

		public string Name { get; }

		public bool FixReference { get; set; }

		public bool SoftReference { get; set; }

		[Obsolete("Use CustomLocation(GameObject, bool, LocationConfig) instead and define if references should be fixed")]
		public CustomLocation(GameObject exteriorPrefab, LocationConfig locationConfig)
			: this(exteriorPrefab, null, fixReference: false, locationConfig)
		{
		}

		[Obsolete("Use CustomLocation(GameObject, GameObject, bool, LocationConfig) instead and define if references should be fixed")]
		public CustomLocation(GameObject exteriorPrefab, GameObject interiorPrefab, LocationConfig locationConfig)
			: this(exteriorPrefab, interiorPrefab, fixReference: false, locationConfig)
		{
		}

		public CustomLocation(GameObject exteriorPrefab, bool fixReference, LocationConfig locationConfig)
			: this(exteriorPrefab, null, fixReference, locationConfig)
		{
		}

		public CustomLocation(GameObject exteriorPrefab, GameObject interiorPrefab, bool fixReference, LocationConfig locationConfig)
			: base(Assembly.GetCallingAssembly())
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			Prefab = exteriorPrefab;
			Name = ((Object)exteriorPrefab).name;
			_locationConfig = locationConfig;
			Location val = default(Location);
			if (exteriorPrefab.TryGetComponent<Location>(ref val))
			{
				Location = val;
			}
			else
			{
				Location = exteriorPrefab.AddComponent<Location>();
				Location.m_clearArea = locationConfig.ClearArea;
				Location.m_exteriorRadius = locationConfig.ExteriorRadius;
				Location.m_interiorPrefab = interiorPrefab;
				Location.m_hasInterior = locationConfig.HasInterior;
				Location.m_interiorRadius = locationConfig.InteriorRadius;
				Location.m_interiorEnvironment = locationConfig.InteriorEnvironment;
			}
			ZoneLocation = locationConfig.GetZoneLocation();
			ZoneLocation.m_prefab = new SoftReference<GameObject>(AssetManager.Instance.AddAsset((Object)(object)exteriorPrefab));
			ZoneLocation.m_prefabName = ((Object)exteriorPrefab).name;
			SyncZoneLocationFromComponent(Location, locationConfig);
			FixReference = fixReference;
		}

		public CustomLocation(SoftReference<GameObject> softReferencePrefab, bool fixReference, LocationConfig locationConfig)
			: base(Assembly.GetCallingAssembly())
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (!softReferencePrefab.IsValid)
			{
				Logger.LogError("SoftReference invalid for prefab: " + softReferencePrefab.Name);
				return;
			}
			_locationConfig = locationConfig;
			Transform transform = ZoneManager.Instance.LocationContainer.transform;
			AssetManager.Instance.ResolveMocksOnLoad<GameObject>(softReferencePrefab, transform, (Action<GameObject>)OnLocationResolve);
			Name = softReferencePrefab.Name;
			ZoneLocation = locationConfig.GetZoneLocation();
			ZoneLocation.m_prefab = softReferencePrefab;
			ZoneLocation.m_prefabName = softReferencePrefab.Name;
			FixReference = fixReference;
			SoftReference = true;
		}

		private void OnLocationResolve(GameObject gameObject)
		{
			gameObject.SetActive(true);
			Location location = default(Location);
			if (gameObject.TryGetComponent<Location>(ref location))
			{
				SyncZoneLocationFromComponent(location, _locationConfig);
			}
			ZoneLocation zoneLocation = default(ZoneLocation);
			if (gameObject.TryGetComponent<ZoneLocation>(ref zoneLocation))
			{
				ZoneManager.Instance.PrepareLocation(zoneLocation, base.SourceMod);
			}
		}

		private void SyncZoneLocationFromComponent(Location location, LocationConfig locationConfig)
		{
			if (!((Object)(object)location == (Object)null) && ZoneLocation != null)
			{
				if (!locationConfig.HasExteriorRadius)
				{
					ZoneLocation.m_exteriorRadius = location.m_exteriorRadius;
				}
				if (!locationConfig.HasInteriorRadius)
				{
					ZoneLocation.m_interiorRadius = location.m_interiorRadius;
				}
				if (!locationConfig.HasClearArea)
				{
					ZoneLocation.m_clearArea = location.m_clearArea;
				}
			}
		}

		public static bool IsCustomLocation(string prefabName)
		{
			return ZoneManager.Instance.Locations.ContainsKey(prefabName);
		}

		public override string ToString()
		{
			return Name;
		}
	}
	public class CustomPiece : CustomEntity
	{
		private string fallbackPieceName;

		private string category;

		public GameObject PiecePrefab { get; }

		public Piece Piece { get; }

		public string PieceTable { get; set; }

		public string Category
		{
			get
			{
				return category;
			}
			set
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				category = value;
				if (Object.op_Implicit((Object)(object)Piece) && !string.IsNullOrEmpty(category))
				{
					Piece.m_category = PieceManager.Instance.AddPieceCategory(category);
				}
			}
		}

		public bool FixReference { get; set; }

		internal bool FixConfig { get; set; }

		private string PieceName
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)PiecePrefab))
				{
					return fallbackPieceName;
				}
				return ((Object)PiecePrefab).name;
			}
		}

		public CustomPiece(GameObject piecePrefab, string pieceTable, bool fixReference)
			: base(Assembly.GetCallingAssembly())
		{
			PiecePrefab = piecePrefab;
			Piece = piecePrefab.GetComponent<Piece>();
			PieceTable = pieceTable;
			FixReference = fixReference;
		}

		[Obsolete("Use CustomPiece(GameObject, bool, PieceConfig) instead and define if references should be fixed")]
		public CustomPiece(GameObject piecePrefab, PieceConfig pieceConfig)
			: base(Assembly.GetCallingAssembly())
		{
			PiecePrefab = piecePrefab;
			Piece = piecePrefab.GetComponent<Piece>();
			PieceTable = pieceConfig.PieceTable;
			FixReference = false;
			FixConfig = true;
			Category = pieceConfig.Category;
			pieceConfig.Apply(piecePrefab);
		}

		public CustomPiece(GameObject piecePrefab, bool fixReference, PieceConfig pieceConfig)
			: base(Assembly.GetCallingAssembly())
		{
			PiecePrefab = piecePrefab;
			Piece = piecePrefab.GetComponent<Piece>();
			PieceTable = pieceConfig.PieceTable;
			FixReference = fixReference;
			FixConfig = true;
			Category = pieceConfig.Category;
			pieceConfig.Apply(piecePrefab);
		}

		public CustomPiece(AssetBundle assetBundle, string assetName, string pieceTable, bool fixReference)
			: base(Assembly.GetCallingAssembly())
		{
			fallbackPieceName = assetName;
			if (AssetUtils.TryLoadPrefab(base.SourceMod, assetBundle, assetName, out var prefab))
			{
				PiecePrefab = prefab;
				Piece = PiecePrefab.GetComponent<Piece>();
				PieceTable = pieceTable;
				FixReference = fixReference;
			}
		}

		[Obsolete("Use CustomPiece(AssetBundle, string, bool, PieceConfig) instead and define if references should be fixed")]
		public CustomPiece(AssetBundle assetBundle, string assetName, PieceConfig pieceConfig)
			: base(Assembly.GetCallingAssembly())
		{
			fallbackPieceName = assetName;
			if (AssetUtils.TryLoadPrefab(base.SourceMod, assetBundle, assetName, out var prefab))
			{
				PiecePrefab = prefab;
				Piece = PiecePrefab.GetComponent<Piece>();
				PieceTable = pieceConfig.PieceTable;
				FixReference = false;
				FixConfig = true;
				Category = pieceConfig.Category;
				pieceConfig.Apply(PiecePrefab);
			}
		}

		public CustomPiece(AssetBundle assetBundle, string assetName, bool fixReference, PieceConfig pieceConfig)
			: base(Assembly.GetCallingAssembly())
		{
			fallbackPieceName = assetName;
			if (AssetUtils.TryLoadPrefab(base.SourceMod, assetBundle, assetName, out var prefab))
			{
				PiecePrefab = prefab;
				Piece = PiecePrefab.GetComponent<Piece>();
				PieceTable = pieceConfig.PieceTable;
				FixReference = fixReference;
				FixConfig = true;
				Category = pieceConfig.Category;
				pieceConfig.Apply(PiecePrefab);
			}
		}

		public CustomPiece(string name, bool addZNetView, string pieceTable)
			: base(Assembly.GetCallingAssembly())
		{
			PiecePrefab = PrefabManager.Instance.CreateEmptyPrefab(name, addZNetView);
			if (!Object.op_Implicit((Object)(object)PiecePrefab))
			{
				fallbackPieceName = name;
				return;
			}
			Piece = PiecePrefab.AddComponent<Piece>();
			Piece.m_name = name;
			PieceTable = pieceTable;
		}

		public CustomPiece(string name, bool addZNetView, PieceConfig pieceConfig)
			: base(Assembly.GetCallingAssembly())
		{
			PiecePrefab = PrefabManager.Instance.CreateEmptyPrefab(name, addZNetView);
			if (!Object.op_Implicit((Object)(object)PiecePrefab))
			{
				fallbackPieceName = name;
				return;
			}
			Piece = PiecePrefab.AddComponent<Piece>();
			PieceTable = pieceConfig.PieceTable;
			FixConfig = true;
			Category = pieceConfig.Category;
			pieceConfig.Apply(PiecePrefab);
		}

		public CustomPiece(string name, string baseName, string pieceTable)
			: base(Assembly.GetCallingAssembly())
		{
			PiecePrefab = PrefabManager.Instance.CreateClonedPrefab(name, baseName);
			if (!Object.op_Implicit((Object)(object)PiecePrefab))
			{
				fallbackPieceName = name;
				return;
			}
			Piece = PiecePrefab.GetComponent<Piece>();
			PieceTable = pieceTable;
		}

		public CustomPiece(string name, string baseName, PieceConfig pieceConfig)
			: base(Assembly.GetCallingAssembly())
		{
			PiecePrefab = PrefabManager.Instance.CreateClonedPrefab(name, baseName);
			if (!Object.op_Implicit((Object)(object)PiecePrefab))
			{
				fallbackPieceName = name;
				return;
			}
			Piece = PiecePrefab.GetComponent<Piece>();
			PieceTable = pieceConfig.PieceTable;
			FixConfig = true;
			Category = pieceConfig.Category;
			pieceConfig.Apply(PiecePrefab);
		}

		public bool IsValid()
		{
			bool result = true;
			if (!Object.op_Implicit((Object)(object)PiecePrefab))
			{
				Logger.LogError(base.SourceMod, $"CustomPiece '{this}' has no prefab");
				result = false;
			}
			if (Object.op_Implicit((Object)(object)PiecePrefab) && !PiecePrefab.IsValid())
			{
				result = false;
			}
			if (!Object.op_Implicit((Object)(object)Piece))
			{
				Logger.LogError(base.SourceMod, $"CustomPiece '{this}' has no Piece component");
				result = false;
			}
			if (Object.op_Implicit((Object)(object)Piece) && !Object.op_Implicit((Object)(object)Piece.m_icon))
			{
				Logger.LogError(base.SourceMod, $"CustomPiece '{this}' has no icon");
				result = false;
			}
			if (string.IsNullOrEmpty(PieceTable))
			{
				Logger.LogError(base.SourceMod, $"CustomPiece '{this}' has no PieceTable");
				result = false;
			}
			return result;
		}

		public static bool IsCustomPiece(string prefabName)
		{
			return PieceManager.Instance.Pieces.ContainsKey(prefabName);
		}

		public override bool Equals(object obj)
		{
			return obj.GetHashCode() == GetHashCode();
		}

		public override int GetHashCode()
		{
			return StringExtensionMethods.GetStableHashCode(PieceName);
		}

		public override string ToString()
		{
			return PieceName;
		}
	}
	public class CustomPieceTable : CustomEntity
	{
		private string fallbackPieceTableName;

		public GameObject PieceTablePrefab { get; }

		public PieceTable PieceTable { get; }

		public string[] Categories { get; set; } = Array.Empty<string>();

		private string PieceTableName
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)PieceTablePrefab))
				{
					return fallbackPieceTableName;
				}
				return ((Object)PieceTablePrefab).name;
			}
		}

		public CustomPieceTable(GameObject pieceTablePrefab)
			: base(Assembly.GetCallingAssembly())
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between I4 and Unknown
			PieceTablePrefab = pieceTablePrefab;
			PieceTable = pieceTablePrefab.GetComponent<PieceTable>();
			if ((Object)(object)PieceTable != (Object)null)
			{
				List<string> list = new List<string>();
				for (int i = 0; i < (int)PieceUtils.VanillaMaxPieceCategory; i++)
				{
					list.Add(Enum.GetName(typeof(PieceCategory), i));
				}
				Categories = list.ToArray();
			}
		}

		public CustomPieceTable(GameObject pieceTablePrefab, PieceTableConfig config)
			: base(Assembly.GetCallingAssembly())
		{
			PieceTablePrefab = pieceTablePrefab;
			config.Apply(pieceTablePrefab);
			PieceTable = pieceTablePrefab.GetComponent<PieceTable>();
			Categories = config.GetCategories();
		}

		public CustomPieceTable(string name, PieceTableConfig config)
			: base(Assembly.GetCallingAssembly())
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			PieceTablePrefab = new GameObject(name);
			PieceTable = PieceTablePrefab.AddComponent<PieceTable>();
			config.Apply(PieceTablePrefab);
			Categories = config.GetCategories();
		}

		public CustomPieceTable(AssetBundle assetBundle, string assetName, PieceTableConfig config)
			: base(Assembly.GetCallingAssembly())
		{
			fallbackPieceTableName = assetName;
			if (AssetUtils.TryLoadPrefab(base.SourceMod, assetBundle, assetName, out var prefab))
			{
				PieceTablePrefab = prefab;
				config.Apply(PieceTablePrefab);
				PieceTable = PieceTablePrefab.GetComponent<PieceTable>();
				Categories = config.GetCategories();
			}
		}

		public bool IsValid()
		{
			bool result = true;
			if (!Object.op_Implicit((Object)(object)PieceTablePrefab))
			{
				Logger.LogError(base.SourceMod, $"CustomPieceTable '{this}' has no prefab");
				result = false;
			}
			if (Object.op_Implicit((Object)(object)PieceTablePrefab) && !PieceTablePrefab.IsValid())
			{
				result = false;
			}
			if ((Object)(object)PieceTable == (Object)null)
			{
				Logger.LogError(base.SourceMod, $"CustomPieceTable '{this}' has no PieceTable component");
				result = false;
			}
			return result;
		}

		public override bool Equals(object obj)
		{
			return obj.GetHashCode() == GetHashCode();
		}

		public override int GetHashCode()
		{
			return StringExtensionMethods.GetStableHashCode(PieceTableName);
		}

		public override string ToString()
		{
			return PieceTableName;
		}
	}
	public class CustomPrefab : CustomEntity, IModPrefab
	{
		private string fallbackPrefabName;

		public GameObject Prefab { get; }

		public bool FixReference { get; set; }

		private string PrefabName
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)Prefab))
				{
					return fallbackPrefabName;
				}
				return ((Object)Prefab).name;
			}
		}

		internal CustomPrefab(GameObject prefab, BepInPlugin sourceMod)
			: base(sourceMod)
		{
			Prefab = prefab;
		}

		public CustomPrefab(GameObject prefab, bool fixReference)
			: base(Assembly.GetCallingAssembly())
		{
			Prefab = prefab;
			FixReference = fixReference;
		}

		public CustomPrefab(AssetBundle assetBundle, string assetName, bool fixReference)
			: base(Assembly.GetCallingAssembly())
		{
			fallbackPrefabName = assetName;
			if (AssetUtils.TryLoadPrefab(base.SourceMod, assetBundle, assetName, out var prefab))
			{
				Prefab = prefab;
				FixReference = fixReference;
			}
		}

		public bool IsValid()
		{
			bool result = true;
			if (!Object.op_Implicit((Object)(object)Prefab))
			{
				Logger.LogError(base.SourceMod, $"CustomPrefab '{this}' has no prefab");
				result = false;
			}
			return result;
		}

		public static bool IsCustomPrefab(string prefabName)
		{
			return PrefabManager.Instance.Prefabs.ContainsKey(prefabName);
		}

		public override string ToString()
		{
			return PrefabName;
		}
	}
	public class CustomRecipe : CustomEntity
	{
		public Recipe Recipe { get; }

		public bool FixReference { get; set; }

		public bool FixRequirementReferences { get; set; }

		public CustomRecipe(Recipe recipe, bool fixReference, bool fixRequirementReferences)
			: base(Assembly.GetCallingAssembly())
		{
			Recipe = recipe;
			FixReference = fixReference;
			FixRequirementReferences = fixRequirementReferences;
		}

		public CustomRecipe(RecipeConfig recipeConfig)
			: base(Assembly.GetCallingAssembly())
		{
			Recipe = recipeConfig.GetRecipe();
			FixReference = true;
			FixRequirementReferences = true;
		}

		public bool IsValid()
		{
			if ((Object)(object)Recipe != (Object)null && Recipe.IsValid())
			{
				return (Object)(object)Recipe.m_item != (Object)null;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			return obj.GetHashCode() == GetHashCode();
		}

		public override int GetHashCode()
		{
			return StringExtensionMethods.GetStableHashCode(((Object)Recipe).name);
		}

		public override string ToString()
		{
			return ((Object)Recipe).name;
		}
	}
	public class CustomRoom : CustomEntity
	{
		public GameObject Prefab { get; }

		public Room Room { get; }

		public string Name { get; }

		public bool FixReference { get; set; }

		public string ThemeName { get; set; }

		public bool SoftReference { get; set; }

		public RoomData RoomData { get; private set; }

		public CustomRoom(AssetBundle assetBundle, string assetName, bool fixReference, RoomConfig roomConfig)
			: base(Assembly.GetCallingAssembly())
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			Prefab = assetBundle.LoadAsset<GameObject>(assetName);
			Name = ((Object)Prefab).name;
			ThemeName = roomConfig.ThemeName;
			Room val = default(Room);
			if ((Object)(object)Prefab != (Object)null && Prefab.TryGetComponent<Room>(ref val))
			{
				Room room = val;
				Room = roomConfig.Apply(room);
			}
			else
			{
				Room room2 = Prefab.AddComponent<Room>();
				Room = roomConfig.Apply(room2);
			}
			FixReference = fixReference;
			RoomData = new RoomData
			{
				m_prefab = new SoftReference<GameObject>(AssetManager.Instance.AddAsset((Object)(object)Prefab)),
				m_loadedRoom = Room,
				m_enabled = Room.m_enabled,
				m_theme = GetRoomTheme(ThemeName)
			};
		}

		public CustomRoom(GameObject prefab, bool fixReference, RoomConfig roomConfig)
			: base(Assembly.GetCallingAssembly())
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			Prefab = prefab;
			Name = ((Object)prefab).name;
			ThemeName = roomConfig.ThemeName;
			Room val = default(Room);
			if ((Object)(object)prefab != (Object)null && prefab.TryGetComponent<Room>(ref val))
			{
				Room room = val;
				Room = roomConfig.Apply(room);
			}
			else
			{
				Room room2 = prefab.AddComponent<Room>();
				Room = roomConfig.Apply(room2);
			}
			FixReference = fixReference;
			RoomData = new RoomData
			{
				m_prefab = new SoftReference<GameObject>(AssetManager.Instance.AddAsset((Object)(object)Prefab)),
				m_loadedRoom = Room,
				m_enabled = Room.m_enabled,
				m_theme = GetRoomTheme(ThemeName)
			};
		}

		public CustomRoom(SoftReference<GameObject> softReferencePrefab, bool fixReference, RoomConfig roomConfig)
			: base(Assembly.GetCallingAssembly())
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			if (!softReferencePrefab.IsValid)
			{
				Logger.LogError("SoftReference invalid for room prefab: " + softReferencePrefab.Name);
				return;
			}
			AssetManager.Instance.ResolveMocksOnLoad<GameObject>(softReferencePrefab, DungeonManager.Instance.DungeonRoomContainer.transform, (Action<GameObject>)OnRoomResolve);
			Name = softReferencePrefab.Name;
			ThemeName = roomConfig.ThemeName;
			FixReference = fixReference;
			SoftReference = true;
			RoomData = new RoomData
			{
				m_prefab = softReferencePrefab,
				m_loadedRoom = null,
				m_enabled = (roomConfig.Enabled ?? true),
				m_theme = GetRoomTheme(ThemeName)
			};
		}

		private void OnRoomResolve(GameObject gameObject)
		{
		}

		public static bool IsCustomRoom(string prefabName)
		{
			return DungeonManager.Instance.Rooms.ContainsKey(prefabName);
		}

		public static bool IsVanillaTheme(string themeName)
		{
			Theme result;
			return Enum.TryParse<Theme>(themeName, ignoreCase: false, out result);
		}

		public static Theme GetRoomTheme(string themeName)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<Theme>(themeName, ignoreCase: false, out Theme result))
			{
				return result;
			}
			return (Theme)0;
		}
	}
	public class CustomRPC : CustomEntity
	{
		private const byte JOTUNN_PACKAGE = 1;

		private const byte FRAGMENTED_PACKAGE = 2;

		private const byte COMPRESSED_PACKAGE = 4;

		private static int CompressMinSize = 10000;

		private static int PackageSliceSize = 250000;

		private static int MaximumSendQueueSize = 20000;

		private static float Timeout = 30f;

		internal NetworkManager.CoroutineHandler OnServerReceive;

		internal NetworkManager.CoroutineHandler OnClientReceive;

		private short SendCount;

		private short ProcessingCount;

		private long PackageCount;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> PackageCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> CacheExpirations = new List<KeyValuePair<long, string>>();

		public string Name { get; }

		public bool IsSending => SendCount > 0;

		public bool IsReceiving => PackageCache.Count > 0;

		public bool IsProcessing => ProcessingCount > 0;

		public bool IsProcessingOther => ProcessingCount - 1 > 0;

		internal string ID => base.SourceMod.GUID + "!" + Name;

		internal CustomRPC(BepInPlugin sourceMod, string name, NetworkManager.CoroutineHandler serverReceive, NetworkManager.CoroutineHandler clientReceive)
			: base(sourceMod)
		{
			Name = name;
			OnServerReceive = serverReceive;
			OnClientReceive = clientReceive;
		}

		public void Initiate()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			ZNet instance = ZNet.instance;
			if (instance != null)
			{
				((MonoBehaviour)instance).StartCoroutine(SendPackageRoutine(ZRoutedRpc.instance.GetServerPeerID(), new ZPackage(new byte[1] { 1 })));
			}
		}

		public void SendPackage(long target, ZPackage package)
		{
			ZNet instance = ZNet.instance;
			if (instance != null)
			{
				((MonoBehaviour)instance).StartCoroutine(SendPackageRoutine(target, package));
			}
		}

		public void SendPackage(List<ZNetPeer> peers, ZPackage package)
		{
			ZNet instance = ZNet.instance;
			if (instance != null)
			{
				((MonoBehaviour)instance).StartCoroutine(SendPackageRoutine(peers, package));
			}
		}

		public IEnumerator SendPackageRoutine(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			if (target == ZRoutedRpc.instance.m_id)
			{
				byte[] array = package.GetArray();
				ZPackage val = new ZPackage();
				val.Write(array);
				val.SetPos(0);
				((MonoBehaviour)ZNet.instance).StartCoroutine(HandlePackageRoutine(ZRoutedRpc.instance.m_id, val, 1));
				yield break;
			}
			List<ZNetPeer> list = ZRoutedRpc.instance.m_peers;
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			yield return SendPackageRoutine(list, package);
		}

		public IEnumerator SendPackageRoutine(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance) || peers.Count == 0)
			{
				yield break;
			}
			try
			{
				SendCount++;
				byte[] array = package.GetArray();
				ZPackage val = new ZPackage();
				val.Write((byte)1);
				val.Write(array);
				val.SetPos(0);
				package = val;
				if (package.Size() > CompressMinSize)
				{
					package = CompressPackage(package);
				}
				List<IEnumerator<bool>> writers = (from p in peers
					where p.IsReady()
					select SendToPeer(p, package)).ToList();
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
				while (writers.Count > 0)
				{
					yield return null;
					writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
				}
			}
			finally
			{
				SendCount--;
			}
		}

		private ZPackage CompressPackage(ZPackage package)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			byte[] array = package.GetArray();
			Logger.LogDebug($"[{ID}] Compressing package with length {array.Length}");
			ZPackage val = new ZPackage();
			val.Write((byte)4);
			MemoryStream memoryStream = new MemoryStream();
			using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Optimal))
			{
				deflateStream.Write(array, 0, array.Length);
			}
			val.Write(memoryStream.ToArray());
			return val;
		}

		private IEnumerator<bool> SendToPeer(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			if (package.Size() > PackageSliceSize)
			{
				byte[] data = package.GetArray();
				int fragments = (int)(1 + (data.LongLength - 1) / PackageSliceSize);
				long packageIdentifier = ++PackageCount;
				for (int fragment = 0; fragment < fragments; fragment++)
				{
					foreach (bool item in WaitForQueue())
					{
						yield return item;
					}
					if (peer.m_socket.IsConnected())
					{
						ZPackage val = new ZPackage();
						val.Write((byte)2);
						val.Write(packageIdentifier);
						val.Write(fragment);
						val.Write(fragments);
						val.Write(data.Skip(PackageSliceSize * fragment).Take(PackageSliceSize).ToArray());
						Logger.LogDebug($"[{ID}] Sending fragmented package {packageIdentifier}:{fragment}");
						Send(val);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in WaitForQueue())
			{
				yield return item2;
			}
			Logger.LogDebug("[" + ID + "] Sending package");
			Send(package);
			void Send(ZPackage pkg)
			{
				rpc.InvokeRoutedRPC(peer.m_uid, ID, new object[1] { pkg });
			}
			IEnumerable<bool> WaitForQueue()
			{
				float timeout = Time.time + Timeout;
				while (peer.m_socket.GetSendQueueSize() > MaximumSendQueueSize)
				{
					if (Time.time > timeout)
					{
						Logger.LogInfo($"Disconnecting {peer.m_uid} after {Timeout} seconds sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						break;
					}
					yield return false;
				}
			}
		}

		internal void ReceivePackage(long sender, ZPackage package)
		{
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			if (package == null || package.Size() <= 0)
			{
				return;
			}
			Logger.LogDebug("[" + ID + "] Received package");
			try
			{
				CacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						PackageCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text = sender.ToString() + num;
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					if (!PackageCache.TryGetValue(text, out var value))
					{
						value = new SortedDictionary<int, byte[]>();
						PackageCache[text] = value;
						CacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text));
					}
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return;
					}
					PackageCache.Remove(text);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				((MonoBehaviour)ZNet.instance).StartCoroutine(HandlePackageRoutine(sender, package, b));
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"[{ID}] Error caught while applying package: {arg}");
			}
		}

		private IEnumerator HandlePackageRoutine(long sender, ZPackage package, byte packageFlags)
		{
			Logger.LogDebug("[" + ID + "] Processing package");
			try
			{
				ProcessingCount++;
				if ((packageFlags & 4) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					packageFlags = package.ReadByte();
					Logger.LogDebug($"[{ID}] Decompressed package to length {memoryStream.Length}");
				}
				if ((packageFlags & 1) != 1)
				{
					Logger.LogWarning($"[{ID}] Package flag does not equal {(byte)1} ({packageFlags:X4})");
					yield break;
				}
				byte[] array = package.ReadByteArray();
				ZPackage val = new ZPackage(array);
				package = val;
				if (!ZNet.instance.IsServer())
				{
					yield return OnClientReceive(sender, package);
				}
				else
				{
					yield return OnServerReceive(sender, package);
				}
			}
			finally
			{
				ProcessingCount--;
			}
		}

		public override string ToString()
		{
			return ID;
		}
	}
	public class CustomStatusEffect : CustomEntity
	{
		public StatusEffect StatusEffect { get; }

		public bool FixReference { get; set; }

		public CustomStatusEffect(StatusEffect statusEffect, bool fixReference)
			: base(Assembly.GetCallingAssembly())
		{
			StatusEffect = statusEffect;
			FixReference = fixReference;
		}

		public bool IsValid()
		{
			if ((Object)(object)StatusEffect != (Object)null)
			{
				return StatusEffect.IsValid();
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			return obj.GetHashCode() == GetHashCode();
		}

		public override int GetHashCode()
		{
			return StringExtensionMethods.GetStableHashCode(((Object)StatusEffect).name);
		}

		public override string ToString()
		{
			return ((Object)StatusEffect).name;
		}
	}
	public class CustomVegetation : CustomEntity
	{
		public GameObject Prefab { get; }

		public ZoneVegetation Vegetation { get; }

		public string Name { get; internal set; }

		public bool FixReference { get; set; }

		[Obsolete("Use CustomVegetation(GameObject, bool, VegetationConfig) instead and define if references should be fixed")]
		public CustomVegetation(GameObject prefab, VegetationConfig config)
			: base(Assembly.GetCallingAssembly())
		{
			Prefab = prefab;
			Name = ((Object)prefab).name;
			Vegetation = config.ToVegetation();
			Vegetation.m_prefab = prefab;
		}

		public CustomVegetation(GameObject prefab, bool fixReference, VegetationConfig config)
			: base(Assembly.GetCallingAssembly())
		{
			Prefab = prefab;
			Name = ((Object)prefab).name;
			Vegetation = config.ToVegetation();
			Vegetation.m_prefab = prefab;
			FixReference = fixReference;
		}

		public CustomVegetation(AssetBundle assetBundle, string assetName, bool fixReference, VegetationConfig config)
			: base(Assembly.GetCallingAssembly())
		{
			Name = assetName;
			if (AssetUtils.TryLoadPrefab(base.SourceMod, assetBundle, assetName, out var prefab))
			{
				Prefab = prefab;
				Vegetation = config.ToVegetation();
				Vegetation.m_prefab = Prefab;
				FixReference = fixReference;
			}
		}

		public static bool IsCustomVegetation(string prefabName)
		{
			return ZoneManager.Instance.Vegetations.ContainsKey(prefabName);
		}

		public bool IsValid()
		{
			bool result = true;
			if (!Object.op_Implicit((Object)(object)Prefab))
			{
				Logger.LogError(base.SourceMod, $"CustomVegetation '{this}' has no prefab");
				result = false;
			}
			return result;
		}

		public override string ToString()
		{
			return Name;
		}
	}
	public class KitbashObject : CustomEntity
	{
		public Action OnKitbashApplied;

		public GameObject Prefab { get; internal set; }

		public KitbashConfig Config { get; internal set; }

		public override string ToString()
		{
			if (!Object.op_Implicit((Object)(object)Prefab))
			{
				return base.ToString();
			}
			return ((Object)Prefab).name;
		}
	}
	public static class Mock<T> where T : Component
	{
		public static T Create(string name)
		{
			return MockManager.Instance.CreateMockedPrefab<T>(name);
		}
	}
	public static class MockRequirement
	{
		public static Requirement Create(string name, int amount = 1, bool recover = true)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			Requirement val = new Requirement
			{
				m_recover = recover,
				m_amount = amount
			};
			val.m_resItem = Mock<ItemDrop>.Create(name);
			return val;
		}

		public static Requirement[] CreateArray(Dictionary<string, int> requirements, bool recover = true)
		{
			List<Requirement> list = new List<Requirement>();
			foreach (KeyValuePair<string, int> requirement in requirements)
			{
				Requirement val = Create(requirement.Key, requirement.Value, recover);
				((object)val).FixReferences();
				list.Add(val);
			}
			return list.ToArray();
		}
	}
}
namespace Jotunn.Configs
{
	public class ButtonConfig
	{
		private KeyCode _key;

		private ConfigEntry<KeyCode> config;

		private KeyboardShortcut _shortcut = KeyboardShortcut.Empty;

		private InputManager.GamepadButton _gamepadButton;

		public string Name { get; set; }

		public string Axis { get; set; } = string.Empty;

		public KeyCode Key
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				if ((int)_key != 0)
				{
					return _key;
				}
				return (KeyCode)(((??)Config?.Value) ?? 0);
			}
			set
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				InputManager.GamepadButton gamepadButton = InputManager.GetGamepadButton(value);
				if (gamepadButton != InputManager.GamepadButton.None)
				{
					Logger.LogWarning($"ButtonConfig: Key {value} is a GamepadButton, setting GamepadButton instead");
					GamepadButton = gamepadButton;
				}
				else
				{
					_key = value;
				}
			}
		}

		public ConfigEntry<KeyCode> Config
		{
			get
			{
				return config;
			}
			set
			{
				if (config != null)
				{
					config.SettingChanged -= OnConfigOnSettingChanged;
				}
				config = value;
				config.SettingChanged += OnConfigOnSettingChanged;
			}
		}

		public KeyboardShortcut Shortcut
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if ((int)((KeyboardShortcut)(ref _shortcut)).MainKey != 0)
				{
					return _shortcut;
				}
				return ShortcutConfig?.Value ?? KeyboardShortcut.Empty;
			}
			set
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				InputManager.GamepadButton gamepadButton = InputManager.GetGamepadButton(((KeyboardShortcut)(ref value)).MainKey);
				if (gamepadButton != InputManager.GamepadButton.None)
				{
					Logger.LogWarning($"ButtonConfig: Shortcut {((KeyboardShortcut)(ref value)).MainKey} is a GamepadButton, setting GamepadButton instead");
					GamepadButton = gamepadButton;
				}
				else
				{
					_shortcut = value;
				}
			}
		}

		public ConfigEntry<KeyboardShortcut> ShortcutConfig { get; set; }

		public InputManager.GamepadButton GamepadButton
		{
			get
			{
				if (_gamepadButton != InputManager.GamepadButton.None)
				{
					return _gamepadButton;
				}
				return GamepadConfig?.Value ?? InputManager.GamepadButton.None;
			}
			set
			{
				_gamepadButton = value;
			}
		}

		public ConfigEntry<InputManager.GamepadButton> GamepadConfig { get; set; }

		public bool Inverted { get; set; }

		public float RepeatDelay { get; set; }

		public float RepeatInterval { get; set; }

		public string Hint { get; set; }

		public string HintToken { get; set; }

		public bool ActiveInGUI { get; set; }

		public bool ActiveInCustomGUI { get; set; }

		public bool BlockOtherInputs { get; set; }

		internal bool IsConfigBacked
		{
			get
			{
				if (Config == null && ShortcutConfig == null)
				{
					return GamepadConfig != null;
				}
				return true;
			}
		}

		private void OnConfigOnSettingChanged(object sender, EventArgs args)
		{
			InputUtils.SetInputButtons((ConfigEntryBase)(object)config);
		}
	}
	public class ClutterConfig
	{
		public bool Enabled { get; set; } = true;

		public Biome Biome { get; set; } = (Biome)(-1);

		public bool Instanced { get; set; }

		public int Amount { get; set; } = 10;

		public bool OnUncleared { get; set; } = true;

		public bool OnCleared { get; set; }

		public float ScaleMin { get; set; } = 1f;

		public float ScaleMax { get; set; } = 1f;

		public float MaxTilt { get; set; } = 25f;

		public float MinAltitude { get; set; }

		public float MaxAltitude { get; set; } = 1000f;

		public bool SnapToWater { get; set; }

		public float RandomOffset { get; set; }

		public bool TerrainTilt { get; set; }

		public bool OceanDepthCheck { get; set; }

		public float MinOceanDepth { get; set; }

		public float MaxOceanDepth { get; set; }

		public bool InForest { get; set; }

		public float ForestThresholdMin { get; set; }

		public float ForestThresholdMax { get; set; } = 1f;

		public float FractalScale { get; set; }

		public float FractalOffset { get; set; }

		public float FractalThresholdMin { get; set; } = 0.5f;

		public float FractalThresholdMax { get; set; } = 1f;

		public ClutterConfig()
		{
		}//IL_0009: Unknown result type (might be due to invalid IL or missing references)


		public ClutterConfig(Clutter clutter)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			Enabled = clutter.m_enabled;
			Biome = clutter.m_biome;
			Instanced = clutter.m_instanced;
			Amount = clutter.m_amount;
			OnUncleared = clutter.m_onUncleared;
			OnCleared = clutter.m_onCleared;
			ScaleMin = clutter.m_scaleMin;
			ScaleMax = clutter.m_scaleMax;
			MaxTilt = clutter.m_maxTilt;
			MinAltitude = clutter.m_minAlt;
			MaxAltitude = clutter.m_maxAlt;
			SnapToWater = clutter.m_snapToWater;
			RandomOffset = clutter.m_randomOffset;
			TerrainTilt = clutter.m_terrainTilt;
			OceanDepthCheck = Math.Abs(clutter.m_minOceanDepth - clutter.m_maxOceanDepth) > 0.001f;
			MinOceanDepth = clutter.m_minOceanDepth;
			MaxOceanDepth = clutter.m_maxOceanDepth;
			InForest = clutter.m_inForest;
			ForestThresholdMin = clutter.m_forestTresholdMin;
			ForestThresholdMax = clutter.m_forestTresholdMax;
			FractalScale = clutter.m_fractalScale;
			FractalOffset = clutter.m_fractalOffset;
			FractalThresholdMin = clutter.m_fractalTresholdMin;
			FractalThresholdMax = clutter.m_fractalTresholdMax;
		}

		internal Clutter ToClutter()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			return new Clutter
			{
				m_enabled = Enabled,
				m_biome = Biome,
				m_instanced = Instanced,
				m_amount = Amount,
				m_onUncleared = OnUncleared,
				m_onCleared = OnCleared,
				m_scaleMin = ScaleMin,
				m_scaleMax = ScaleMax,
				m_maxTilt = MaxTilt,
				m_minAlt = MinAltitude,
				m_maxAlt = MaxAltitude,
				m_snapToWater = SnapToWater,
				m_randomOffset = RandomOffset,
				m_terrainTilt = TerrainTilt,
				m_minOceanDepth = (OceanDepthCheck ? MinOceanDepth : 0f),
				m_maxOceanDepth = (OceanDepthCheck ? MaxOceanDepth : 0f),
				m_inForest = InForest,
				m_forestTresholdMin = ForestThresholdMin,
				m_forestTresholdMax = ForestThresholdMax,
				m_fractalScale = FractalScale,
				m_fractalOffset = FractalOffset,
				m_fractalTresholdMin = FractalThresholdMin,
				m_fractalTresholdMax = FractalThresholdMax
			};
		}
	}
	public abstract class ConversionConfig
	{
		public abstract string Station { get; set; }

		public virtual string FromItem { get; set; }

		public string ToItem { get; set; }
	}
	public class CookingConversionConfig : ConversionConfig
	{
		private string station = CookingStations.CookingStation;

		public override string Station
		{
			get
			{
				return station;
			}
			set
			{
				station = CookingStations.GetInternalName(value);
			}
		}

		public float CookTime { get; set; } = 10f;

		public ItemConversion GetItemConversion()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			return new ItemConversion
			{
				m_cookTime = CookTime,
				m_from = Mock<ItemDrop>.Create(FromItem),
				m_to = Mock<ItemDrop>.Create(base.ToItem)
			};
		}

		public static CookingConversionConfig FromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<CookingConversionConfig>(json);
		}

		public static List<CookingConversionConfig> ListFromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<List<CookingConversionConfig>>(json);
		}
	}
	public static class CookingStations
	{
		private static readonly Dictionary<string, string> NamesMap = new Dictionary<string, string>
		{
			{ "CookingStation", CookingStation },
			{ "IronCookingStation", IronCookingStation },
			{ "StoneOven", StoneOven }
		};

		private static readonly AcceptableValueList<string> AcceptableValues = new AcceptableValueList<string>(NamesMap.Keys.ToArray());

		public static string CookingStation => "piece_cookingstation";

		public static string IronCookingStation => "piece_cookingstation_iron";

		public static string StoneOven => "piece_oven";

		public static Dictionary<string, string> GetNames()
		{
			return NamesMap;
		}

		public static AcceptableValueList<string> GetAcceptableValueList()
		{
			return AcceptableValues;
		}

		public static string GetInternalName(string cookingStation)
		{
			if (string.IsNullOrEmpty(cookingStation))
			{
				return string.Empty;
			}
			if (NamesMap.TryGetValue(cookingStation, out var value))
			{
				return value;
			}
			return cookingStation;
		}
	}
	public static class CraftingStations
	{
		private static readonly Dictionary<string, string> NamesMap = new Dictionary<string, string>
		{
			{ "None", None },
			{ "Workbench", Workbench },
			{ "Forge", Forge },
			{ "Stonecutter", Stonecutter },
			{ "Cauldron", Cauldron },
			{ "ArtisanTable", ArtisanTable },
			{ "BlackForge", BlackForge },
			{ "GaldrTable", GaldrTable },
			{ "MeadKetill", MeadKetill },
			{ "FoodPreparationTable", FoodPreparationTable }
		};

		private static readonly AcceptableValueList<string> AcceptableValues = new AcceptableValueList<string>(NamesMap.Keys.ToArray());

		public static string None => string.Empty;

		public static string Workbench => "piece_workbench";

		public static string Forge => "forge";

		public static string Stonecutter => "piece_stonecutter";

		public static string Cauldron => "piece_cauldron";

		public static string ArtisanTable => "piece_artisanstation";

		public static string BlackForge => "blackforge";

		public static string GaldrTable => "piece_magetable";

		public static string MeadKetill => "piece_MeadCauldron";

		public static string FoodPreparationTable => "piece_preptable";

		public static Dictionary<string, string> GetNames()
		{
			return NamesMap;
		}

		public static AcceptableValueList<string> GetAcceptableValueList()
		{
			return AcceptableValues;
		}

		public static string GetInternalName(string craftingStation)
		{
			if (string.IsNullOrEmpty(craftingStation))
			{
				return None;
			}
			if (NamesMap.TryGetValue(craftingStation, out var value))
			{
				return value;
			}
			return craftingStation;
		}
	}
	public class CreatureConfig
	{
		public DropConfig[] DropConfigs = Array.Empty<DropConfig>();

		public SpawnConfig[] SpawnConfigs = Array.Empty<SpawnConfig>();

		public string[] Consumables = Array.Empty<string>();

		public string Name { get; set; } = string.Empty;

		public string Group { get; set; } = string.Empty;

		public Faction? Faction { get; set; }

		public bool UseCumulativeLevelEffects { get; set; }

		public void Apply(GameObject prefab)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			Character val = default(Character);
			if (!prefab.TryGetComponent<Character>(ref val))
			{
				Logger.LogError("GameObject " + ((Object)prefab).name + " has no Character component attached");
				return;
			}
			if (!string.IsNullOrEmpty(Name))
			{
				val.m_name = Name;
			}
			if (string.IsNullOrEmpty(val.m_name))
			{
				val.m_name = ((Object)prefab).name;
			}
			if (!string.IsNullOrEmpty(Group))
			{
				val.m_group = Group;
			}
			if (Faction.HasValue)
			{
				val.m_faction = Faction.Value;
			}
			List<Drop> list = GetDrops().ToList();
			if (list.Any())
			{
				CharacterDrop orAddComponent = prefab.GetOrAddComponent<CharacterDrop>();
				orAddComponent.m_drops = list;
			}
			List<ItemDrop> list2 = GetConsumeItems().ToList();
			MonsterAI val2 = default(MonsterAI);
			if (list2.Any() && prefab.TryGetComponent<MonsterAI>(ref val2))
			{
				val2.m_consumeItems = list2;
			}
		}

		public Drop[] GetDrops()
		{
			Drop[] array = (Drop[])(object)new Drop[DropConfigs.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = DropConfigs[i].GetDrop();
			}
			return array;
		}

		public SpawnData[] GetSpawns()
		{
			SpawnData[] array = (SpawnData[])(object)new SpawnData[SpawnConfigs.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = SpawnConfigs[i].GetSpawnData();
			}
			return array;
		}

		public ItemDrop[] GetConsumeItems()
		{
			ItemDrop[] array = (ItemDrop[])(object)new ItemDrop[Consumables.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = Mock<ItemDrop>.Create(Consumables[i]);
			}
			return array;
		}

		public void AddDropConfig(DropConfig dropConfig)
		{
			DropConfigs = CollectionExtensions.AddToArray<DropConfig>(DropConfigs, dropConfig);
		}

		public void AddSpawnConfig(SpawnConfig spawnConfig)
		{
			SpawnConfigs = CollectionExtensions.AddToArray<SpawnConfig>(SpawnConfigs, spawnConfig);
		}

		public void AddConsumable(string consumable)
		{
			Consumables = CollectionExtensions.AddToArray<string>(Consumables, consumable);
		}
	}
	public class DropConfig
	{
		public string Item { get; set; } = string.Empty;

		public int MinAmount { get; set; } = 1;

		public int MaxAmount { get; set; } = 1;

		public float Chance { get; set; } = 100f;

		public bool OnePerPlayer { get; set; }

		public bool LevelMultiplier { get; set; } = true;

		public Drop GetDrop()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			return new Drop
			{
				m_prefab = MockManager.Instance.CreateMockedGameObject(Item),
				m_amountMin = MinAmount,
				m_amountMax = ((MaxAmount < MinAmount) ? MinAmount : MaxAmount),
				m_chance = Chance / 100f,
				m_onePerPlayer = OnePerPlayer,
				m_levelMultiplier = LevelMultiplier
			};
		}
	}
	public class FermenterConversionConfig : ConversionConfig
	{
		private string station = Fermenters.Fermenter;

		public override string Station
		{
			get
			{
				return station;
			}
			set
			{
				station = Fermenters.GetInternalName(value);
			}
		}

		public int ProducedItems { get; set; } = 4;

		public ItemConversion GetItemConversion()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			return new ItemConversion
			{
				m_producedItems = ProducedItems,
				m_from = Mock<ItemDrop>.Create(FromItem),
				m_to = Mock<ItemDrop>.Create(base.ToItem)
			};
		}

		public static FermenterConversionConfig FromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<FermenterConversionConfig>(json);
		}

		public static List<FermenterConversionConfig> ListFromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<List<FermenterConversionConfig>>(json);
		}
	}
	public class Fermenters
	{
		private static readonly Dictionary<string, string> NamesMap = new Dictionary<string, string> { { "Fermenter", Fermenter } };

		private static readonly AcceptableValueList<string> AcceptableValues = new AcceptableValueList<string>(NamesMap.Keys.ToArray());

		public static string Fermenter => "fermenter";

		public static Dictionary<string, string> GetNames()
		{
			return NamesMap;
		}

		public static AcceptableValueList<string> GetAcceptableValueList()
		{
			return AcceptableValues;
		}

		public static string GetInternalName(string fermenter)
		{
			if (string.IsNullOrEmpty(fermenter))
			{
				return string.Empty;
			}
			if (NamesMap.TryGetValue(fermenter, out var value))
			{
				return value;
			}
			return fermenter;
		}
	}
	public class IncineratorConversionConfig : ConversionConfig
	{
		private string station = Incinerators.Incinerator;

		public override string Station
		{
			get
			{
				return station;
			}
			set
			{
				station = Incinerators.GetInternalName(value);
			}
		}

		public List<IncineratorRequirementConfig> Requirements { get; set; } = new List<IncineratorRequirementConfig>();

		public int ProducedItems { get; set; } = 1;

		public int Priority { get; set; }

		public bool RequireOnlyOneIngredient { get; set; }

		public IncineratorConversion GetIncineratorConversion()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			FromItem = ((Requirements.Count > 0) ? string.Empty : null);
			return new IncineratorConversion
			{
				m_requirements = Requirements.Select((IncineratorRequirementConfig x) => x.GetRequirement()).ToList(),
				m_result = Mock<ItemDrop>.Create(base.ToItem),
				m_resultAmount = ProducedItems,
				m_priority = Priority,
				m_requireOnlyOneIngredient = RequireOnlyOneIngredient
			};
		}

		public static IncineratorConversionConfig FromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<IncineratorConversionConfig>(json);
		}

		public static List<IncineratorConversionConfig> ListFromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<List<IncineratorConversionConfig>>(json);
		}
	}
	public class IncineratorRequirementConfig
	{
		public string Item { get; set; }

		public int Amount { get; set; }

		public IncineratorRequirementConfig()
		{
		}

		public IncineratorRequirementConfig(string item, int amount)
		{
			Item = item;
			Amount = amount;
		}

		public Requirement GetRequirement()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			return new Requirement
			{
				m_resItem = Mock<ItemDrop>.Create(Item),
				m_amount = Amount
			};
		}
	}
	public class Incinerators
	{
		private static readonly Dictionary<string, string> NamesMap = new Dictionary<string, string> { { "Incinerator", Incinerator } };

		private static readonly AcceptableValueList<string> AcceptableValues = new AcceptableValueList<string>(NamesMap.Keys.ToArray());

		public static string Incinerator => "incinerator";

		public static Dictionary<string, string> GetNames()
		{
			return NamesMap;
		}

		public static AcceptableValueList<string> GetAcceptableValueList()
		{
			return AcceptableValues;
		}

		public static string GetInternalName(string incinerator)
		{
			if (string.IsNullOrEmpty(incinerator))
			{
				return string.Empty;
			}
			if (NamesMap.TryGetValue(incinerator, out var value))
			{
				return value;
			}
			return incinerator;
		}
	}
	public class ItemConfig
	{
		public int StackSize = -1;

		private string craftingStation = string.Empty;

		private string repairStation = string.Empty;

		public string Name { get; set; } = string.Empty;

		public string Description { get; set; } = string.Empty;

		public string Item { get; internal set; }

		public int Amount { get; set; } = 1;

		public bool Enabled { get; set; } = true;

		public string PieceTable { get; set; } = string.Empty;

		public string CraftingStation
		{
			get
			{
				return craftingStation;
			}
			set
			{
				craftingStation = CraftingStations.GetInternalName(value);
			}
		}

		public string RepairStation
		{
			get
			{
				return repairStation;
			}
			set
			{
				repairStation = CraftingStations.GetInternalName(value);
			}
		}

		public int MinStationLevel { get; set; } = 1;

		public bool RequireOnlyOneIngredient { get; set; }

		public int QualityResultAmountMultiplier { get; set; } = 1;

		public float Weight { get; set; } = -1f;

		public Sprite[] Icons { get; set; }

		public Sprite Icon
		{
			get
			{
				Sprite[] icons = Icons;
				if (icons == null || icons.Length < 1)
				{
					return null;
				}
				return Icons[0];
			}
			set
			{
				if (Icons == null || Icons.Length == 0)
				{
					Icons = (Sprite[])(object)new Sprite[1] { value };
				}
				else
				{
					Icons[0] = value;
				}
			}
		}

		public Texture2D StyleTex { get; set; }

		public RequirementConfig[] Requirements { get; set; } = Array.Empty<RequirementConfig>();

		public void Apply(GameObject prefab)
		{
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				Logger.LogError("GameObject has no ItemDrop attached");
				return;
			}
			SharedData shared = component.m_itemData.m_shared;
			if (shared == null)
			{
				Logger.LogError("ItemDrop has no SharedData component");
				return;
			}
			Item = ((Object)prefab).name;
			if (!string.IsNullOrEmpty(Name))
			{
				shared.m_name = Name;
			}
			if (!string.IsNullOrEmpty(Description))
			{
				shared.m_description = Description;
			}
			if (string.IsNullOrEmpty(shared.m_name))
			{
				shared.m_name = "$" + ((Object)prefab).name;
			}
			if (!string.IsNullOrEmpty(PieceTable))
			{
				shared.m_buildPieces = Mock<PieceTable>.Create(PieceTable);
			}
			if (Weight >= 0f)
			{
				shared.m_weight = Weight;
			}
			if (StackSize >= 1)
			{
				shared.m_maxStackSize = StackSize;
			}
			if (Icons != null && Icons.Length != 0)
			{
				component.m_itemData.m_shared.m_icons = Icons;
				if ((Object)(object)StyleTex != (Object)null)
				{
					ExtEquipment.Enable();
				}
			}
		}

		public Requirement[] GetRequirements()
		{
			List<Requirement> list = new List<Requirement>();
			RequirementConfig[] requirements = Requirements;
			foreach (RequirementConfig requirementConfig in requirements)
			{
				if (requirementConfig != null && requirementConfig.IsValid())
				{
					list.Add(requirementConfig.GetRequirement());
				}
			}
			return list.ToArray();
		}

		public Recipe GetRecipe()
		{
			if (Item == null)
			{
				Logger.LogError("No item set in item config");
				return null;
			}
			if (Requirements == null || Requirements.Length == 0)
			{
				return null;
			}
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			((Object)val).name = "Recipe_" + Item;
			val.m_item = Mock<ItemDrop>.Create(Item);
			val.m_amount = Amount;
			val.m_enabled = Enabled;
			if (!string.IsNullOrEmpty(CraftingStation))
			{
				val.m_craftingStation = Mock<CraftingStation>.Create(CraftingStation);
			}
			if (!string.IsNullOrEmpty(RepairStation))
			{
				val.m_repairStation = Mock<CraftingStation>.Create(RepairStation);
			}
			val.m_minStationLevel = MinStationLevel;
			val.m_resources = GetRequirements();
			val.m_requireOnlyOneIngredient = RequireOnlyOneIngredient;
			val.m_qualityResultAmountMultiplier = QualityResultAmountMultiplier;
			return val;
		}

		public static ItemConfig FromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<ItemConfig>(json);
		}

		public static List<ItemConfig> ListFromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<List<ItemConfig>>(json);
		}

		public void AddRequirement(RequirementConfig requirementConfig)
		{
			if (requirementConfig != null && requirementConfig.IsValid())
			{
				Requirements = CollectionExtensions.AddToArray<RequirementConfig>(Requirements, requirementConfig);
			}
		}

		public void AddRequirement(string item, int amount, int amountPerLevel = 0)
		{
			AddRequirement(new RequirementConfig(item, amount, amountPerLevel));
		}
	}
	public class KeyHintConfig
	{
		internal bool Dirty;

		public string Item { get; set; } = string.Empty;

		public string Piece { get; set; } = string.Empty;

		public ButtonConfig[] ButtonConfigs { get; set; } = Array.Empty<ButtonConfig>();

		public override string ToString()
		{
			string text = Item;
			if (!string.IsNullOrEmpty(Piece))
			{
				text = text + ":" + Piece;
			}
			return text;
		}
	}
	public class KitbashConfig
	{
		public List<KitbashSourceConfig> KitbashSources = new List<KitbashSourceConfig>();

		public string Layer { get; set; }

		public bool FixReferences { get; set; }
	}
	public class KitbashSourceConfig
	{
		public string Name { get; set; }

		public string TargetParentPath { get; set; }

		public string SourcePrefab { get; set; }

		public string SourcePath { get; set; }

		public Vector3 Position { get; set; } = Vector3.zero;

		public Quaternion Rotation { get; set; } = Quaternion.identity;

		public Vector3 Scale { get; set; } = Vector3.one;

		public string[] Materials { get; set; }

		public override string ToString()
		{
			if (!string.IsNullOrEmpty(Name))
			{
				return Name;
			}
			if (!string.IsNullOrEmpty(SourcePrefab))
			{
				return SourcePrefab;
			}
			return base.ToString();
		}
	}
	[Obsolete("Use CustomLocalization instead")]
	public class LocalizationConfig
	{
		public Dictionary<string, string> Translations = new Dictionary<string, string>();

		public string Language { get; set; } = "English";

		public LocalizationConfig(string language)
		{
			Language = language;
		}
	}
	public class LocationConfig
	{
		private float? _exteriorRadius;

		private float? _interiorRadius;

		private bool? _clearArea;

		[Obsolete("Not valid because no prefab is associated in LocationConfig, use CustomLocation.Location instead.")]
		public Location Location { get; internal set; }

		public Biome Biome { get; set; }

		public BiomeArea BiomeArea { get; set; } = (BiomeArea)3;

		public bool Priotized { get; set; }

		public int Quantity { get; set; }

		[Obsolete("This property is unused by Valheim.")]
		public float ChanceToSpawn { get; set; } = 10f;

		public float ExteriorRadius
		{
			get
			{
				return _exteriorRadius ?? 10f;
			}
			set
			{
				_exteriorRadius = value;
			}
		}

		internal bool HasExteriorRadius => _exteriorRadius.HasValue;

		public bool CenterFirst { get; set; }

		public bool InForest { get; set; }

		public float ForestTresholdMin { get; set; }

		public float ForestTrasholdMax { get; set; } = 1f;

		public bool Unique { get; set; }

		public float MinAltitude { get; set; } = -1000f;

		public float MaxAltitude { get; set; } = 1000f;

		public float MinDistance { get; set; }

		public float MaxDistance { get; set; }

		public string Group { get; set; } = string.Empty;

		public float MinDistanceFromSimilar { get; set; }

		public float MinTerrainDelta { get; set; }

		public float MaxTerrainDelta { get; set; } = 2f;

		public bool SlopeRotation { get; set; }

		public bool HasInterior { get; set; }

		public float InteriorRadius
		{
			get
			{
				return _interiorRadius.GetValueOrDefault();
			}
			set
			{
				_interiorRadius = value;
			}
		}

		internal bool HasInteriorRadius => _interiorRadius.HasValue;

		public string InteriorEnvironment { get; set; }

		public bool RandomRotation { get; set; } = true;

		public bool SnapToWater { get; set; }

		public bool IconPlaced { get; set; }

		public bool IconAlways { get; set; }

		public bool ClearArea
		{
			get
			{
				return _clearArea == true;
			}
			set
			{
				_clearArea = value;
			}
		}

		internal bool HasClearArea => _clearArea.HasValue;

		public LocationConfig()
		{
		}//IL_0002: Unknown result type (might be due to invalid IL or missing references)


		public LocationConfig(ZoneLocation zoneLocation)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			zoneLocation.m_prefab.Load();
			Location component = zoneLocation.m_prefab.Asset.GetComponent<Location>();
			Biome = zoneLocation.m_biome;
			BiomeArea = zoneLocation.m_biomeArea;
			Priotized = zoneLocation.m_prioritized;
			Quantity = zoneLocation.m_quantity;
			ExteriorRadius = zoneLocation.m_exteriorRadius;
			ForestTresholdMin = zoneLocation.m_forestTresholdMin;
			ForestTrasholdMax = zoneLocation.m_forestTresholdMax;
			MinDistance = zoneLocation.m_minDistance;
			MaxDistance = zoneLocation.m_maxDistance;
			MinAltitude = zoneLocation.m_minAltitude;
			MaxAltitude = zoneLocation.m_maxAltitude;
			Group = zoneLocation.m_group;
			InForest = zoneLocation.m_inForest;
			MinTerrainDelta = zoneLocation.m_minTerrainDelta;
			MaxTerrainDelta = zoneLocation.m_maxTerrainDelta;
			MinDistanceFromSimilar = zoneLocation.m_minDistanceFromSimilar;
			HasInterior = Object.op_Implicit((Object)(object)component) && component.m_hasInterior;
			InteriorRadius = zoneLocation.m_interiorRadius;
			InteriorEnvironment = component?.m_interiorEnvironment;
			SlopeRotation = zoneLocation.m_slopeRotation;
			RandomRotation = zoneLocation.m_randomRotation;
			SnapToWater = zoneLocation.m_snapToWater;
			IconPlaced = zoneLocation.m_iconPlaced;
			IconAlways = zoneLocation.m_iconAlways;
			ClearArea = Object.op_Implicit((Object)(object)component) && component.m_clearArea;
			zoneLocation.m_prefab.Release();
		}

		public ZoneLocation GetZoneLocation()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			return new ZoneLocation
			{
				m_biome = Biome,
				m_biomeArea = BiomeArea,
				m_quantity = Quantity,
				m_prioritized = Priotized,
				m_interiorRadius = InteriorRadius,
				m_exteriorRadius = ExteriorRadius,
				m_clearArea = ClearArea,
				m_centerFirst = CenterFirst,
				m_forestTresholdMin = ForestTresholdMin,
				m_forestTresholdMax = ForestTrasholdMax,
				m_unique = Unique,
				m_minAltitude = MinAltitude,
				m_maxAltitude = MaxAltitude,
				m_minDistance = MinDistance,
				m_maxDistance = MaxDistance,
				m_group = Group,
				m_inForest = InForest,
				m_minTerrainDelta = MinTerrainDelta,
				m_maxTerrainDelta = MaxTerrainDelta,
				m_minDistanceFromSimilar = MinDistanceFromSimilar,
				m_slopeRotation = SlopeRotation,
				m_randomRotation = RandomRotation,
				m_snapToWater = SnapToWater,
				m_iconPlaced = IconPlaced,
				m_iconAlways = IconAlways
			};
		}
	}
	public static class PieceCategories
	{
		private static readonly Dictionary<string, string> NamesMap = new Dictionary<string, string>
		{
			{ "Misc", Misc },
			{ "Crafting", Crafting },
			{ "Building", Building },
			{ "HeavyBuild", HeavyBuild },
			{ "Furniture", Furniture },
			{ "Feasts", Feasts },
			{ "Food", Food },
			{ "Mead", Mead },
			{ "All", All }
		};

		private static readonly AcceptableValueList<string> AcceptableValues = new AcceptableValueList<string>(NamesMap.Keys.ToArray());

		public static string Misc => "Misc";

		public static string Crafting => "Crafting";

		public static string Building => "BuildingWorkbench";

		public static string HeavyBuild => "BuildingStonecutter";

		public static string Furniture => "Furniture";

		public static string Food => "Food";

		public static string Mead => "Meads";

		public static string Feasts => "Feasts";

		public static string All => "All";

		public static Dictionary<string, string> GetNames()
		{
			return NamesMap;
		}

		public static AcceptableValueList<string> GetAcceptableValueList()
		{
			return AcceptableValues;
		}

		public static string GetInternalName(string pieceCategory)
		{
			if (string.IsNullOrEmpty(pieceCategory))
			{
				return string.Empty;
			}
			if (NamesMap.TryGetValue(pieceCategory, out var value))
			{
				return value;
			}
			return pieceCategory;
		}
	}
	public class PieceConfig
	{
		private string pieceTable = string.Empty;

		private string category = string.Empty;

		private string craftingStation = string.Empty;

		private string extendStation = string.Empty;

		public string Name { get; set; } = string.Empty;

		public string Description { get; set; } = string.Empty;

		public bool Enabled { get; set; } = true;

		public bool AllowedInDungeons { get; set; }

		public string PieceTable
		{
			get
			{
				return pieceTable;
			}
			set
			{
				pieceTable = PieceTables.GetInternalName(value);
			}
		}

		public string Category
		{
			get
			{
				return category;
			}
			set
			{
				category = PieceCategories.GetInternalName(value);
			}
		}

		public string CraftingStation
		{
			get
			{
				return craftingStation;
			}
			set
			{
				craftingStation = CraftingStations.GetInternalName(value);
			}
		}

		public string ExtendStation
		{
			get
			{
				return extendStation;
			}
			set
			{
				extendStation = CraftingStations.GetInternalName(value);
			}
		}

		public Sprite Icon { get; set; }

		public RequirementConfig[] Requirements { get; set; } = Array.Empty<RequirementConfig>();

		public void Apply(GameObject prefab)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			Piece component = prefab.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null)
			{
				Logger.LogWarning("GameObject has no Piece attached");
				return;
			}
			component.m_enabled = Enabled;
			component.m_allowedInDungeons = AllowedInDungeons;
			if (!string.IsNullOrEmpty(Name))
			{
				component.m_name = Name;
			}
			if (!string.IsNullOrEmpty(Description))
			{
				component.m_description = Description;
			}
			if ((Object)(object)Icon != (Object)null)
			{
				component.m_icon = Icon;
			}
			if (Requirements.Length != 0)
			{
				component.m_resources = GetRequirements();
			}
			if (!string.IsNullOrEmpty(CraftingStation))
			{
				component.m_craftingStation = Mock<CraftingStation>.Create(CraftingStation);
			}
			if (!string.IsNullOrEmpty(ExtendStation))
			{
				StationExtension orAddComponent = prefab.GetOrAddComponent<StationExtension>();
				orAddComponent.m_craftingStation = Mock<CraftingStation>.Create(ExtendStation);
			}
			if (!string.IsNullOrEmpty(Category))
			{
				component.m_category = PieceManager.Instance.AddPieceCategory(Category);
			}
		}

		public Requirement[] GetRequirements()
		{
			List<Requirement> list = new List<Requirement>();
			RequirementConfig[] requirements = Requirements;
			foreach (RequirementConfig requirementConfig in requirements)
			{
				if (requirementConfig != null && requirementConfig.IsValid())
				{
					list.Add(requirementConfig.GetRequirement());
				}
			}
			return list.ToArray();
		}

		public static PieceConfig FromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<PieceConfig>(json);
		}

		public static List<PieceConfig> ListFromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<List<PieceConfig>>(json);
		}

		public void AddRequirement(RequirementConfig requirementConfig)
		{
			if (requirementConfig != null && requirementConfig.IsValid())
			{
				Requirements = CollectionExtensions.AddToArray<RequirementConfig>(Requirements, requirementConfig);
			}
		}

		public void AddRequirement(string item, int amount, bool recover = true)
		{
			AddRequirement(new RequirementConfig(item, amount, 0, recover));
		}
	}
	public class PieceTableConfig
	{
		public bool UseCategories { get; set; } = true;

		public bool UseCustomCategories { get; set; }

		public string[] CustomCategories { get; set; } = Array.Empty<string>();

		public bool CanRemovePieces { get; set; } = true;

		public string[] GetCategories()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between I4 and Unknown
			List<string> list = new List<string>();
			if (UseCategories)
			{
				for (int i = 0; i < (int)PieceUtils.VanillaMaxPieceCategory; i++)
				{
					list.Add(Enum.GetName(typeof(PieceCategory), i));
				}
			}
			if (UseCustomCategories)
			{
				string[] customCategories = CustomCategories;
				foreach (string item in customCategories)
				{
					list.Add(item);
				}
			}
			return list.ToArray();
		}

		public void Apply(GameObject prefab)
		{
			PieceTable component = prefab.GetComponent<PieceTable>();
			if ((Object)(object)component == (Object)null)
			{
				Logger.LogWarning("GameObject has no PieceTable attached");
			}
			else
			{
				component.m_canRemovePieces = CanRemovePieces;
			}
		}
	}
	public static class PieceTables
	{
		private static readonly Dictionary<string, string> NamesMap = new Dictionary<string, string>
		{
			{ "Hammer", Hammer },
			{ "Cultivator", Cultivator },
			{ "Hoe", Hoe },
			{ "ServingTray", ServingTray }
		};

		private static readonly AcceptableValueList<string> AcceptableValues = new AcceptableValueList<string>(NamesMap.Keys.ToArray());

		public static string Hammer => "_HammerPieceTable";

		public static string Cultivator => "_CultivatorPieceTable";

		public static string Hoe => "_HoePieceTable";

		public static string ServingTray => "_FeasterPieceTable";

		public static Dictionary<string, string> GetNames()
		{
			return NamesMap;
		}

		public static AcceptableValueList<string> GetAcceptableValueList()
		{
			return AcceptableValues;
		}

		public static string GetInternalName(string pieceTable)
		{
			if (string.IsNullOrEmpty(pieceTable))
			{
				return string.Empty;
			}
			if (NamesMap.TryGetValue(pieceTable, out var value))
			{
				return value;
			}
			return pieceTable;
		}
	}
	public class RecipeConfig
	{
		private string craftingStation = string.Empty;

		private string repairStation = string.Empty;

		public string Name { get; set; } = string.Empty;

		public string Item { get; set; } = string.Empty;

		public int Amount { get; set; } = 1;

		public bool Enabled { get; set; } = true;

		public string CraftingStation
		{
			get
			{
				return craftingStation;
			}
			set
			{
				craftingStation = CraftingStations.GetInternalName(value);
			}
		}

		public string RepairStation
		{
			get
			{
				return repairStation;
			}
			set
			{
				repairStation = CraftingStations.GetInternalName(value);
			}
		}

		public int MinStationLevel { get; set; } = 1;

		public bool RequireOnlyOneIngredient { get; set; }

		public int QualityResultAmountMultiplier { get; set; } = 1;

		public RequirementConfig[] Requirements { get; set; } = Array.Empty<RequirementConfig>();

		public Requirement[] GetRequirements()
		{
			List<Requirement> list = new List<Requirement>();
			RequirementConfig[] requirements = Requirements;
			foreach (RequirementConfig requirementConfig in requirements)
			{
				if (requirementConfig != null && requirementConfig.IsValid())
				{
					list.Add(requirementConfig.GetRequirement());
				}
			}
			return list.ToArray();
		}

		public Recipe GetRecipe()
		{
			if (Item == null)
			{
				Logger.LogError("No item set in recipe config");
				return null;
			}
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			string text = Name;
			if (string.IsNullOrEmpty(text))
			{
				text = "Recipe_" + Item;
			}
			((Object)val).name = text;
			val.m_item = Mock<ItemDrop>.Create(Item);
			val.m_amount = Amount;
			val.m_enabled = Enabled;
			if (!string.IsNullOrEmpty(CraftingStation))
			{
				val.m_craftingStation = Mock<CraftingStation>.Create(CraftingStation);
			}
			if (!string.IsNullOrEmpty(RepairStation))
			{
				val.m_repairStation = Mock<CraftingStation>.Create(RepairStation);
			}
			val.m_minStationLevel = MinStationLevel;
			val.m_resources = GetRequirements();
			val.m_requireOnlyOneIngredient = RequireOnlyOneIngredient;
			val.m_qualityResultAmountMultiplier = QualityResultAmountMultiplier;
			return val;
		}

		public static RecipeConfig FromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<RecipeConfig>(json);
		}

		public static List<RecipeConfig> ListFromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<List<RecipeConfig>>(json);
		}

		public void AddRequirement(RequirementConfig requirementConfig)
		{
			if (requirementConfig != null && requirementConfig.IsValid())
			{
				Requirements = CollectionExtensions.AddToArray<RequirementConfig>(Requirements, requirementConfig);
			}
		}

		public void AddRequirement(string item, int amount, int amountPerLevel = 0)
		{
			AddRequirement(new RequirementConfig(item, amount, amountPerLevel));
		}
	}
	public class RequirementConfig
	{
		public string Item { get; set; } = string.Empty;

		public int Amount { get; set; } = 1;

		public int AmountPerLevel { get; set; }

		public bool Recover { get; set; } = true;

		public RequirementConfig()
		{
		}

		public RequirementConfig(string item, int amount, int amountPerLevel = 0, bool recover = true)
		{
			Item = item;
			Amount = amount;
			AmountPerLevel = amountPerLevel;
			Recover = recover;
		}

		public Requirement GetRequirement()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			return new Requirement
			{
				m_resItem = Mock<ItemDrop>.Create(Item),
				m_amount = Amount,
				m_amountPerLevel = AmountPerLevel,
				m_recover = Recover
			};
		}

		public bool IsValid()
		{
			if (!string.IsNullOrEmpty(Item))
			{
				if (Amount <= 0)
				{
					return AmountPerLevel > 0;
				}
				return true;
			}
			return false;
		}
	}
	public class RoomConfig
	{
		public string ThemeName { get; set; }

		public bool? Enabled { get; set; }

		public bool? Entrance { get; set; }

		public bool? Endcap { get; set; }

		public bool? Divider { get; set; }

		public int? EndcapPrio { get; set; }

		public int? MinPlaceOrder { get; set; }

		public float? Weight { get; set; }

		public bool? FaceCenter { get; set; }

		public bool? Perimeter { get; set; }

		public RoomConfig(string themeName)
		{
			ThemeName = themeName;
		}

		public RoomConfig()
		{
		}

		public Room Apply(Room room)
		{
			if (Enabled.HasValue)
			{
				room.m_enabled = Enabled.Value;
			}
			if (Entrance.HasValue)
			{
				room.m_entrance = Entrance.Value;
			}
			if (Endcap.HasValue)
			{
				room.m_endCap = Endcap.Value;
			}
			if (Divider.HasValue)
			{
				room.m_divider = Divider.Value;
			}
			if (EndcapPrio.HasValue)
			{
				room.m_endCapPrio = EndcapPrio.Value;
			}
			if (MinPlaceOrder.HasValue)
			{
				room.m_minPlaceOrder = MinPlaceOrder.Value;
			}
			if (Weight.HasValue)
			{
				room.m_weight = Weight.Value;
			}
			if (FaceCenter.HasValue)
			{
				room.m_faceCenter = FaceCenter.Value;
			}
			if (Perimeter.HasValue)
			{
				room.m_perimeter = Perimeter.Value;
			}
			if (Perimeter.HasValue)
			{
				room.m_perimeter = Perimeter.Value;
			}
			return room;
		}
	}
	public class SkillConfig
	{
		private string _identifier;

		public SkillType UID { get; private set; }

		public string Identifier
		{
			get
			{
				return _identifier;
			}
			set
			{
				int num = Math.Abs(StringExtensionMethods.GetStableHashCode(value));
				if (num > 999)
				{
					_identifier = value;
					UID = (SkillType)num;
					return;
				}
				throw new Exception("This identifier may conflict with default Valheim skills, please choose a different (or longer) identifer");
			}
		}

		public string Name { get; set; }

		public string Description { get; set; }

		public Sprite Icon { get; set; }

		public float IncreaseStep { get; set; } = 1f;

		public string IconPath
		{
			set
			{
				if ((Object)(object)Icon != (Object)null)
				{
					Logger.LogWarning("Icon and IconPath both set for skill " + Identifier + ", ignoring IconPath");
				}
				else
				{
					Icon = AssetUtils.LoadSprite(value);
				}
			}
		}

		internal string LocalizedName
		{
			get
			{
				if (!Name.StartsWith("$"))
				{
					return Name;
				}
				return Localization.instance.Localize(Name);
			}
		}

		public override string ToString()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return $"SkillConfig(Identifier='{Identifier}', UID={UID}, Name='{Name}')";
		}

		public SkillDef ToSkillDef()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			return new SkillDef
			{
				m_description = Description,
				m_icon = Icon,
				m_increseStep = IncreaseStep,
				m_skill = UID
			};
		}

		internal bool IsFromName(string name)
		{
			if (!string.Equals(Name, name, StringComparison.CurrentCultureIgnoreCase) && !(Identifier == name))
			{
				return string.Equals(Localization.instance.Localize(Name), name, StringComparison.CurrentCultureIgnoreCase);
			}
			return true;
		}

		[Obsolete("This is kept for easy compatibility with SkillInjector. Use other ways of registering skills if possible to avoid conflicts with other mods")]
		public static SkillConfig FromSkillInjector(string identifier, SkillType uid, string name, string description, float increaseStep, Sprite icon)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return new SkillConfig
			{
				Identifier = identifier,
				UID = uid,
				Name = name,
				Description = description,
				Icon = icon,
				IncreaseStep = increaseStep
			};
		}

		public static SkillConfig FromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<SkillConfig>(json);
		}

		public static List<SkillConfig> ListFromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<List<SkillConfig>>(json);
		}
	}
	public class SmelterConversionConfig : ConversionConfig
	{
		private string station = Smelters.Smelter;

		public override string Station
		{
			get
			{
				return station;
			}
			set
			{
				station = Smelters.GetInternalName(value);
			}
		}

		public ItemConversion GetItemConversion()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			return new ItemConversion
			{
				m_from = Mock<ItemDrop>.Create(FromItem),
				m_to = Mock<ItemDrop>.Create(base.ToItem)
			};
		}

		public static SmelterConversionConfig FromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<SmelterConversionConfig>(json);
		}

		public static List<SmelterConversionConfig> ListFromJson(string json)
		{
			return global::SimpleJson.SimpleJson.DeserializeObject<List<SmelterConversionConfig>>(json);
		}
	}
	public static class Smelters
	{
		private static readonly Dictionary<string, string> NamesMap = new Dictionary<string, string>
		{
			{ "Smelter", Smelter },
			{ "BlastFurnace", BlastFurnace },
			{ "CharcoalKiln", CharcoalKiln },
			{ "EitrRefinery", EitrRefinery },
			{ "Bathtub", Bathtub },
			{ "SpinningWheel", SpinningWheel },
			{ "Windmill", Windmill }
		};

		private static readonly AcceptableValueList<string> AcceptableValues = new AcceptableValueList<string>(NamesMap.Keys.ToArray());

		public static string Smelter => "smelter";

		public static string BlastFurnace => "blastfurnace";

		public static string CharcoalKiln => "charcoal_kiln";

		public static string EitrRefinery => "eitrrefinery";

		public static string Bathtub => "piece_bathtub";

		public static string SpinningWheel => "piece_spinningwheel";

		public static string Windmill => "windmill";

		public static Dictionary<string, string> GetNames()
		{
			return NamesMap;
		}

		public static AcceptableValueList<string> GetAcceptableValueList()
		{
			return AcceptableValues;
		}

		public static string GetInternalName(string smelter)
		{
			if (string.IsNullOrEmpty(smelter))
			{
				return string.Empty;
			}
			if (NamesMap.TryGetValue(smelter, out var value))
			{
				return value;
			}
			return smelter;
		}
	}
	public class SpawnConfig
	{
		public string Name { get; set; } = string.Empty;

		public bool WorldSpawnEnabled { get; set; } = true;

		public Biome Biome { get; set; }

		public BiomeArea BiomeArea { get; set; } = (BiomeArea)3;

		public int MaxSpawned { get; set; } = 1;

		public float SpawnInterval { get; set; } = 4f;

		public float SpawnChance { get; set; } = 100f;

		public float SpawnDistance { get; set; } = 10f;

		public float MinSpawnRadius { get; set; }

		public float MaxSpawnRadius { get; set; }

		public int MinLevel { get; set; } = 1;

		public int MaxLevel { get; set; } = 1;

		public string RequiredGlobalKey { get; set; }

		public List<string> RequiredEnvironments { get; set; } = new List<string>();

		public int MinGroupSize { get; set; } = 1;

		public int MaxGroupSize { get; set; } = 1;

		public float GroupRadius { get; set; } = 3f;

		public bool SpawnAtDay { get; set; } = true;

		public bool SpawnAtNight { get; set; } = true;

		public float MinAltitude { get; set; } = -1000f;

		public float MaxAltitude { get; set; } = 1000f;

		public float MinTilt { get; set; }

		public float MaxTilt { get; set; } = 35f;

		public float MinOceanDepth { get; set; }

		public float MaxOceanDepth { get; set; }

		public bool SpawnInForest { get; set; } = true;

		public bool SpawnOutsideForest { get; set; } = true;

		public bool HuntPlayer { get; set; }

		public float GroundOffset { get; set; } = 0.5f;

		public SpawnData GetSpawnData()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			return new SpawnData
			{
				m_name = Name,
				m_enabled = WorldSpawnEnabled,
				m_biome = Biome,
				m_biomeArea = BiomeArea,
				m_maxSpawned = ((MaxSpawned < 1) ? 1 : MaxSpawned),
				m_spawnInterval = SpawnInterval,
				m_spawnChance = SpawnChance,
				m_spawnDistance = SpawnDistance,
				m_spawnRadiusMin = MinSpawnRadius,
				m_spawnRadiusMax = ((MaxSpawnRadius < MinSpawnRadius) ? MinSpawnRadius : MaxSpawnRadius),
				m_requiredGlobalKey = RequiredGlobalKey,
				m_requiredEnvironments = RequiredEnvironments,
				m_groupSizeMin = MinGroupSize,
				m_groupSizeMax = ((MaxGroupSize < MinGroupSize) ? MinGroupSize : MaxGroupSize),
				m_spawnAtNight = SpawnAtNight,
				m_spawnAtDay = SpawnAtDay,
				m_minAltitude = MinAltitude,
				m_maxAltitude = ((MaxAltitude < MinAltitude) ? MinAltitude : MaxAltitude),
				m_minTilt = MinTilt,
				m_maxTilt = ((MaxTilt < MinTilt) ? MinTilt : MaxTilt),
				m_inForest = SpawnInForest,
				m_outsideForest = SpawnOutsideForest,
				m_minOceanDepth = MinOceanDepth,
				m_maxOceanDepth = ((MaxOceanDepth < MinOceanDepth) ? MinOceanDepth : MaxOceanDepth),
				m_huntPlayer = HuntPlayer,
				m_groundOffset = GroundOffset,
				m_minLevel = MinLevel,
				m_maxLevel = ((MaxLevel < MinLevel) ? MinLevel : MaxLevel)
			};
		}
	}
	public class VegetationConfig
	{
		public Biome Biome { get; set; }

		public BiomeArea BiomeArea { get; set; } = (BiomeArea)3;

		public bool BlockCheck { get; set; } = true;

		public bool ForcePlacement { get; set; }

		public float Min { get; set; }

		public float Max { get; set; } = 10f;

		public float MinAltitude { get; set; } = -1000f;

		public float MaxAltitude { get; set; } = 1000f;

		public float MinOceanDepth { get; set; }

		public float MaxOceanDepth { get; set; }

		public float MinTerrainDelta { get; set; }

		public float MaxTerrainDelta { get; set; } = 2f;

		public float MinTilt { get; set; }

		public float MaxTilt { get; set; } = 90f;

		public bool InForest { get; set; }

		public float ForestThresholdMin { get; set; }

		public float ForestThresholdMax { get; set; } = 1f;

		public float TerrainDeltaRadius { get; set; }

		public float ScaleMin { get; set; } = 1f;

		public float ScaleMax { get; set; } = 1f;

		public int GroupSizeMin { get; set; } = 1;

		public int GroupSizeMax { get; set; } = 1;

		public float GroupRadius { get; set; }

		public float GroundOffset { get; set; }

		public VegetationConfig()
		{
		}//IL_0002: Unknown result type (might be due to invalid IL or missing references)


		public VegetationConfig(ZoneVegetation zoneVegetation)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			Biome = zoneVegetation.m_biome;
			BiomeArea = zoneVegetation.m_biomeArea;
			Min = zoneVegetation.m_min;
			Max = zoneVegetation.m_max;
			BlockCheck = zoneVegetation.m_blockCheck;
			ForcePlacement = zoneVegetation.m_forcePlacement;
			MinAltitude = zoneVegetation.m_minAltitude;
			MaxAltitude = zoneVegetation.m_maxAltitude;
			MinOceanDepth = zoneVegetation.m_minOceanDepth;
			MaxOceanDepth = zoneVegetation.m_maxOceanDepth;
			MinTerrainDelta = zoneVegetation.m_minTerrainDelta;
			MaxTerrainDelta = zoneVegetation.m_maxTerrainDelta;
			TerrainDeltaRadius = zoneVegetation.m_terrainDeltaRadius;
			MinTilt = zoneVegetation.m_minTilt;
			MaxTilt = zoneVegetation.m_maxTilt;
			InForest = zoneVegetation.m_inForest;
			ForestThresholdMin = zoneVegetation.m_forestTresholdMin;
			ForestThresholdMax = zoneVegetation.m_forestTresholdMax;
			ScaleMin = zoneVegetation.m_scaleMin;
			ScaleMax = zoneVegetation.m_scaleMax;
			GroupSizeMin = zoneVegetation.m_groupSizeMin;
			GroupSizeMax = zoneVegetation.m_groupSizeMax;
			GroupRadius = zoneVegetation.m_groupRadius;
			GroundOffset = zoneVegetation.m_groundOffset;
		}

		internal ZoneVegetation ToVegetation()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			return new ZoneVegetation
			{
				m_biome = Biome,
				m_biomeArea = BiomeArea,
				m_enable = true,
				m_min = Min,
				m_max = Max,
				m_blockCheck = BlockCheck,
				m_forcePlacement = ForcePlacement,
				m_minAltitude = MinAltitude,
				m_maxAltitude = MaxAltitude,
				m_minOceanDepth = MinOceanDepth,
				m_maxOceanDepth = MaxOceanDepth,
				m_minTerrainDelta = MinTerrainDelta,
				m_maxTerrainDelta = MaxTerrainDelta,
				m_terrainDeltaRadius = TerrainDeltaRadius,
				m_minTilt = MinTilt,
				m_maxTilt = MaxTilt,
				m_inForest = InForest,
				m_forestTresholdMin = ForestThresholdMin,
				m_forestTresholdMax = ForestThresholdMax,
				m_scaleMin = ScaleMin,
				m_scaleMax = ScaleMax,
				m_groupSizeMin = GroupSizeMin,
				m_groupSizeMax = GroupSizeMax,
				m_groupRadius = GroupRadius,
				m_groundOffset = GroundOffset
			};
		}
	}
}