using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CommunityPatchExtras.Common;
using CommunityPatchExtras.Patches;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using SimpleJson;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("CommunityPatchExtras")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CommunityPatchExtras")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("0.1.1")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.1.0")]
namespace CommunityPatchExtras
{
	internal static class ConfigFileWatcher
	{
		private class WatchEntry
		{
			internal DateTime LastWriteUTC;

			internal long FileLength;

			internal Action<string> Callback;
		}

		internal class ConfigFileWatcherBehaviour : MonoBehaviour
		{
			private float nextPollTime;

			public void Update()
			{
				if (!(Time.unscaledTime < nextPollTime))
				{
					nextPollTime = Time.unscaledTime + PollInterval();
					Poll();
				}
			}

			private static float PollInterval()
			{
				if (ValConfig.ConfigPollIntervalSeconds == null)
				{
					return 30f;
				}
				return ValConfig.ConfigPollIntervalSeconds.Value;
			}

			private static void Poll()
			{
				if (WatchedFiles.Count == 0)
				{
					return;
				}
				string[] array = WatchedFiles.Keys.ToArray();
				foreach (string text in array)
				{
					if (!WatchedFiles.TryGetValue(text, out var value) || !File.Exists(text))
					{
						continue;
					}
					FileInfo fileInfo = new FileInfo(text);
					DateTime lastWriteTimeUtc = fileInfo.LastWriteTimeUtc;
					long length = fileInfo.Length;
					if (!(lastWriteTimeUtc == value.LastWriteUTC) || length != value.FileLength)
					{
						value.LastWriteUTC = lastWriteTimeUtc;
						value.FileLength = length;
						try
						{
							value.Callback?.Invoke(text);
						}
						catch (Exception ex)
						{
							Logger.LogWarning("ConfigFileWatcher callback for " + text + " threw: " + ex.Message);
						}
					}
				}
			}
		}

		private const float FallbackPollSeconds = 30f;

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

		private static ConfigFileWatcherBehaviour watchProcess;

		internal static void Initialize()
		{
			//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_001e: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)watchProcess != (Object)null))
			{
				GameObject val = new GameObject("ValheimCommunityPatchExtras_ConfigFileWatcher");
				Object.DontDestroyOnLoad((Object)val);
				((Object)val).hideFlags = (HideFlags)61;
				watchProcess = val.AddComponent<ConfigFileWatcherBehaviour>();
				Logger.LogDebug("ConfigFileWatcher initialized.");
			}
		}

		internal static void Register(string fullPath, Action<string> onChanged)
		{
			if (!string.IsNullOrEmpty(fullPath))
			{
				DateTime lastWriteUTC = DateTime.MinValue;
				long fileLength = 0L;
				if (File.Exists(fullPath))
				{
					FileInfo fileInfo = new FileInfo(fullPath);
					lastWriteUTC = fileInfo.LastWriteTimeUtc;
					fileLength = fileInfo.Length;
				}
				WatchedFiles[fullPath] = new WatchEntry
				{
					LastWriteUTC = lastWriteUTC,
					FileLength = fileLength,
					Callback = onChanged
				};
				Logger.LogDebug("ConfigFileWatcher watching " + fullPath);
			}
		}

		internal static void RefreshStamp(string fullPath)
		{
			if (string.IsNullOrEmpty(fullPath) || !WatchedFiles.TryGetValue(fullPath, out var value))
			{
				return;
			}
			try
			{
				FileInfo fileInfo = new FileInfo(fullPath);
				value.LastWriteUTC = fileInfo.LastWriteTimeUtc;
				value.FileLength = fileInfo.Length;
			}
			catch (Exception)
			{
				value.LastWriteUTC = DateTime.MinValue;
				value.FileLength = 0L;
			}
		}
	}
	internal static class ConfigNetwork
	{
		private static bool initialized;

		private static Harmony harmony;

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

		private const byte EditProtocolVersion = 1;

		internal static bool ServerConfigsSynced { get; private set; }

		internal static event Action<YamlConfigFile, bool, string> EditResult;

		internal static void Init()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			if (initialized)
			{
				return;
			}
			initialized = true;
			SynchronizationManager.OnConfigurationSynchronized += OnConfigurationSynchronized;
			try
			{
				harmony = new Harmony("MidnightsFX.ValheimCommunityPatchExtras.config");
				harmony.Patch((MethodBase)AccessTools.Method(typeof(ZNet), "Shutdown", (Type[])null, (Type[])null), new HarmonyMethod(typeof(ConfigNetwork), "ResetOnWorldUnload", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Could not patch ZNet.Shutdown for config sync teardown: " + ex.Message);
			}
		}

		internal static void RegisterFile(YamlConfigFile file)
		{
			//IL_00d4: 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_00ea: Expected O, but got Unknown
			//IL_00ea: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01a5: Expected O, but got Unknown
			if (file == null || file.Sync == ConfigSyncMode.LocalOnly)
			{
				return;
			}
			if (string.IsNullOrEmpty(file.RpcName))
			{
				file.RpcName = "ValheimCommunityPatchExtras_" + Path.GetFileNameWithoutExtension(file.FileName);
			}
			if (!usedRpcNames.Add(file.RpcName))
			{
				Logger.LogError("Config RPC name '" + file.RpcName + "' is already in use; " + file.FileName + " will not be synced. Give it an explicit RpcName.");
				return;
			}
			file.Rpc = NetworkManager.Instance.AddRPC(file.RpcName, (CoroutineHandler)((long sender, ZPackage package) => OnServerReceive(file, sender, package)), (CoroutineHandler)((long sender, ZPackage package) => OnClientReceive(file, sender, package)));
			SynchronizationManager.Instance.AddInitialSynchronization(file.Rpc, (Func<ZPackage>)(() => SendFileAsZPackage(file)));
			if (!file.AllowAdminEdit)
			{
				return;
			}
			string text = file.RpcName + "_Edit";
			if (!usedRpcNames.Add(text))
			{
				Logger.LogError("Config RPC name '" + text + "' is already in use; " + file.FileName + " will not accept admin edits.");
			}
			else
			{
				file.EditRpc = NetworkManager.Instance.AddRPC(text, (CoroutineHandler)((long sender, ZPackage package) => OnServerReceiveEdit(file, sender, package)), (CoroutineHandler)((long sender, ZPackage package) => OnClientReceiveEditResult(file, sender, package)));
			}
		}

		internal static bool RequestEdit(YamlConfigFile file, string yaml, out string refusal)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			refusal = "";
			if (file == null || file.EditRpc == null)
			{
				refusal = "this config cannot be edited remotely.";
				return false;
			}
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer())
			{
				refusal = "not connected to a server as a client.";
				return false;
			}
			if (SynchronizationManager.Instance != null && !SynchronizationManager.Instance.PlayerIsAdmin)
			{
				refusal = "only server admins can change this.";
				return false;
			}
			ZPackage val = new ZPackage();
			val.Write((byte)1);
			val.Write(yaml);
			file.EditRpc.SendPackage(ZRoutedRpc.instance.GetServerPeerID(), val);
			return true;
		}

		private static IEnumerator OnServerReceiveEdit(YamlConfigFile file, long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				yield break;
			}
			byte b = package.ReadByte();
			if (b != 1)
			{
				SendEditResult(sender, file, accepted: false, $"This server expects edit protocol v{(byte)1}, " + $"the sender used v{b}. Update so both sides match.");
				yield break;
			}
			string yaml = package.ReadString();
			string message;
			if (!SenderIsAdmin(sender))
			{
				Logger.LogWarning($"Rejecting an edit of {file.FileName} from non-admin peer {sender}.");
				SendEditResult(sender, file, accepted: false, "Only server admins can change " + file.FileName + ".");
			}
			else if (!YamlConfigManager.ApplyEdited(file, yaml, out message))
			{
				Logger.LogWarning($"Admin peer {sender} sent a {file.FileName} that was rejected: {message}");
				SendEditResult(sender, file, accepted: false, message);
			}
			else
			{
				Logger.LogInfo($"{file.FileName} was replaced by admin peer {sender}.");
				SendEditResult(sender, file, accepted: true, message);
				yield return null;
			}
		}

		private static IEnumerator OnClientReceiveEditResult(YamlConfigFile file, long sender, ZPackage package)
		{
			if (package.ReadByte() != 1)
			{
				ConfigNetwork.EditResult?.Invoke(file, arg2: false, "The server answered with an edit protocol this build does not understand.");
				yield break;
			}
			bool arg = package.ReadBool();
			string arg2 = package.ReadString();
			ConfigNetwork.EditResult?.Invoke(file, arg, arg2);
			yield return null;
		}

		private static void SendEditResult(long peer, YamlConfigFile file, bool accepted, string message)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			if (file.EditRpc != null)
			{
				ZPackage val = new ZPackage();
				val.Write((byte)1);
				val.Write(accepted);
				val.Write(message ?? "");
				file.EditRpc.SendPackage(peer, val);
			}
		}

		internal static void Broadcast(YamlConfigFile file)
		{
			if (file != null && file.Rpc != null && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				file.Rpc.SendPackage(ZNet.instance.m_peers, SendFileAsZPackage(file));
			}
		}

		internal static void ResetServerSyncState()
		{
			ServerConfigsSynced = false;
		}

		private static void OnConfigurationSynchronized(object sender, EventArgs e)
		{
			ServerConfigsSynced = true;
		}

		private static void ResetOnWorldUnload()
		{
			ResetServerSyncState();
		}

		private static IEnumerator OnServerReceive(YamlConfigFile file, long sender, ZPackage package)
		{
			Logger.LogDebug($"Peer {sender} sent {file.FileName}; this config is server-authoritative, ignoring.");
			yield break;
		}

		private static IEnumerator OnClientReceive(YamlConfigFile file, long sender, ZPackage package)
		{
			string text = package.ReadString();
			file.LoadFrom(text, ConfigOrigin.ServerSync);
			if (file.ClientWritesToDisk)
			{
				YamlConfigManager.WriteRawToDisk(file, text);
			}
			yield return null;
		}

		private static ZPackage SendFileAsZPackage(YamlConfigFile file)
		{
			//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();
			try
			{
				val.Write(File.Exists(file.Path) ? File.ReadAllText(file.Path) : file.SerializeCurrent());
			}
			catch (Exception ex)
			{
				Logger.LogError("Could not read " + file.FileName + " to send to peers: " + ex.Message);
				val.Write("");
			}
			return val;
		}

		internal static bool SenderIsAdmin(long sender)
		{
			ZNet instance = ZNet.instance;
			ZNetPeer val = ((instance != null) ? instance.GetPeer(sender) : null);
			if (val == null || val.m_socket == null)
			{
				return false;
			}
			return ZNet.instance.IsAdmin(val.m_socket.GetHostName());
		}
	}
	internal class ValidationReport
	{
		internal readonly List<string> Warnings = new List<string>();

		internal readonly List<string> Errors = new List<string>();

		internal bool HasErrors => Errors.Count > 0;

		internal ValidationReport Warn(string message)
		{
			Warnings.Add(message);
			return this;
		}

		internal ValidationReport Error(string message)
		{
			Errors.Add(message);
			return this;
		}

		internal ValidationReport Absorb(ValidationReport other)
		{
			if (other == null)
			{
				return this;
			}
			Warnings.AddRange(other.Warnings);
			Errors.AddRange(other.Errors);
			return this;
		}
	}
	internal static class ConfigValidation
	{
		internal static float Prefer(float bepInExValue, float yamlValue, float sentinel = 0f)
		{
			if (bepInExValue != sentinel)
			{
				return bepInExValue;
			}
			return yamlValue;
		}

		internal static string SuggestKey(string unknownKey, IEnumerable<string> knownKeys)
		{
			if (string.IsNullOrEmpty(unknownKey) || knownKeys == null)
			{
				return "";
			}
			int num = Math.Max(1, unknownKey.Length / 4);
			string text = null;
			int num2 = int.MaxValue;
			foreach (string knownKey in knownKeys)
			{
				if (!string.IsNullOrEmpty(knownKey))
				{
					int num3 = Distance(unknownKey, knownKey);
					if (num3 < num2)
					{
						num2 = num3;
						text = knownKey;
					}
				}
			}
			if (text == null || num2 > num)
			{
				return "";
			}
			return " Did you mean '" + text + "'?";
		}

		private static int Distance(string a, string b)
		{
			a = a.ToLowerInvariant();
			b = b.ToLowerInvariant();
			if (a == b)
			{
				return 0;
			}
			if (a.Length == 0)
			{
				return b.Length;
			}
			if (b.Length == 0)
			{
				return a.Length;
			}
			int[] array = new int[b.Length + 1];
			int[] array2 = new int[b.Length + 1];
			for (int i = 0; i <= b.Length; i++)
			{
				array[i] = i;
			}
			for (int j = 1; j <= a.Length; j++)
			{
				array2[0] = j;
				for (int k = 1; k <= b.Length; k++)
				{
					int num = ((a[j - 1] != b[k - 1]) ? 1 : 0);
					array2[k] = Math.Min(Math.Min(array2[k - 1] + 1, array[k] + 1), array[k - 1] + num);
				}
				int[] array3 = array;
				array = array2;
				array2 = array3;
			}
			return array[b.Length];
		}
	}
	internal static class YamlConfigManager
	{
		internal static YamlConfigFile<ExampleSettings> ExampleFile;

		internal static YamlConfigFile<Dictionary<string, int>> ExampleSavedDataFile;

		private const string ExampleHeader = "#################################################\n# CommunityPatchExtras - Example settings\n#\n# Entries is a map of <key>: <entry>. The key is the identity used elsewhere in this mod, so\n# renaming one is a breaking change; DisplayName is only a label and is safe to change.\n#\n#   DisplayName  string   Shown to the player.\n#   Multiplier   float    Scales the thing. 1.0 is unchanged. Range 0.1 - 10.\n#   Mode         enum     Off | Add | Multiply\n#   Prefabs      list     Prefab names this entry applies to. Unknown names are warned about\n#                         and skipped, they do not break the file.\n#\n# A typo in a key or an enum value costs you that one setting and logs a warning naming the\n# line; the rest of the file still loads.\n#################################################";

		private static bool initialized;

		private static readonly List<YamlConfigFile> Files = new List<YamlConfigFile>();

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

		internal static IEnumerable<YamlConfigFile> All => Files;

		private static void RegisterConfigFiles()
		{
			RegisterExampleConfigs();
		}

		private static void RegisterExampleConfigs()
		{
			ExampleFile = Register(new YamlConfigFile<ExampleSettings>("ExampleSettings.yaml")
			{
				Header = "#################################################\n# CommunityPatchExtras - Example settings\n#\n# Entries is a map of <key>: <entry>. The key is the identity used elsewhere in this mod, so\n# renaming one is a breaking change; DisplayName is only a label and is safe to change.\n#\n#   DisplayName  string   Shown to the player.\n#   Multiplier   float    Scales the thing. 1.0 is unchanged. Range 0.1 - 10.\n#   Mode         enum     Off | Add | Multiply\n#   Prefabs      list     Prefab names this entry applies to. Unknown names are warned about\n#                         and skipped, they do not break the file.\n#\n# A typo in a key or an enum value costs you that one setting and logs a warning naming the\n# line; the rest of the file still loads.\n#################################################",
				Defaults = () => ExampleData.BuildDefaults(),
				Apply = delegate(ExampleSettings parsed)
				{
					ExampleData.Current = parsed;
				},
				Validate = ExampleData.Validate,
				NeedsPrefabs = true,
				SchemaVersion = 1,
				GetSchemaVersion = (ExampleSettings settings) => settings.Version,
				SetSchemaVersion = delegate(ExampleSettings settings, int version)
				{
					settings.Version = version;
				}
			});
			ExampleSavedDataFile = Register(new YamlConfigFile<Dictionary<string, int>>("ExampleSavedData.yaml")
			{
				SubFolder = "SavedData",
				Header = "# Save data written by this mod. Edit it with the game closed.",
				Defaults = () => new Dictionary<string, int>(),
				Apply = delegate(Dictionary<string, int> parsed)
				{
					ExampleData.SavedCounters = parsed;
				},
				Sync = ConfigSyncMode.LocalOnly,
				Watch = false
			});
			Register(new YamlConfigFile<Dictionary<string, ExampleEntry>>("ExampleLegacyFormat.yaml")
			{
				Header = "# A config kept in its original camelCase form for backwards compatibility.",
				Format = YamlFormat.CamelCase,
				Defaults = () => new Dictionary<string, ExampleEntry>(),
				Apply = delegate(Dictionary<string, ExampleEntry> parsed)
				{
					ExampleData.LegacyEntries = parsed;
				},
				ClientWritesToDisk = true
			});
		}

		internal static void Init()
		{
			if (!initialized)
			{
				initialized = true;
				ConfigNetwork.Init();
				YamlFormat.AddTypeConverter((IYamlTypeConverter)(object)new TolerantEnumConverter());
				RegisterConfigFiles();
				ConfigFileWatcher.Initialize();
				Logger.LogDebug($"Registered {Files.Count} yaml config files.");
			}
		}

		internal static TFile Register<TFile>(TFile file) where TFile : YamlConfigFile
		{
			if (file == null)
			{
				return null;
			}
			Files.Add(file);
			if (initialized)
			{
				Prepare(file);
			}
			return file;
		}

		internal static YamlConfigFile Find(string fileNameOrPath)
		{
			if (string.IsNullOrEmpty(fileNameOrPath))
			{
				return null;
			}
			if (ByPath.TryGetValue(fileNameOrPath, out var value))
			{
				return value;
			}
			for (int i = 0; i < Files.Count; i++)
			{
				if (string.Equals(Files[i].FileName, fileNameOrPath, StringComparison.OrdinalIgnoreCase))
				{
					return Files[i];
				}
			}
			return null;
		}

		internal static string ConfigDirectory(string subFolder = null)
		{
			string text = Path.Combine(Paths.ConfigPath, ValConfig.cfgFolder);
			if (!string.IsNullOrEmpty(subFolder))
			{
				text = Path.Combine(text, subFolder);
			}
			return Directory.CreateDirectory(text).FullName;
		}

		internal static void ReloadFromDisk(YamlConfigFile file, bool broadcast = true)
		{
			if (file == null)
			{
				return;
			}
			try
			{
				if (!File.Exists(file.Path))
				{
					Logger.LogWarning(file.FileName + " is no longer on disk; rewriting it with this mod's built-in defaults.");
					RestoreDefaults(file);
				}
				if (file.LoadFrom(File.ReadAllText(file.Path), ConfigOrigin.LocalFile) && broadcast)
				{
					ConfigNetwork.Broadcast(file);
				}
			}
			catch (Exception ex)
			{
				Logger.LogError("Could not reload " + file.FileName + ": " + ex.Message);
			}
		}

		internal static bool ApplyEdited(YamlConfigFile file, string yaml, out string message)
		{
			message = "";
			if (file == null)
			{
				message = "no config file was named";
				return false;
			}
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				message = file.FileName + " belongs to the server; changes have to be sent to it.";
				return false;
			}
			string parseError;
			ValidationReport validationReport = file.DryRun(yaml, out parseError);
			if (parseError != null)
			{
				message = file.FileName + " was rejected because " + parseError + ".";
				return false;
			}
			if (validationReport.HasErrors)
			{
				message = string.Join(" ", validationReport.Errors.ToArray());
				return false;
			}
			if (!file.LoadFrom(yaml, ConfigOrigin.Api))
			{
				message = file.LastError ?? (file.FileName + " could not be applied.");
				return false;
			}
			WriteRawToDisk(file, yaml);
			ConfigNetwork.Broadcast(file);
			message = ((validationReport.Warnings.Count == 0) ? "" : string.Join(" ", validationReport.Warnings.ToArray()));
			return true;
		}

		internal static string SerializeForEdit<T>(YamlConfigFile<T> file, T value) where T : class
		{
			if (file == null || value == null)
			{
				return "";
			}
			return file.EffectiveFormat.Serializer.Serialize((object)value);
		}

		internal static void RestoreDefaults(YamlConfigFile file)
		{
			WriteRawToDisk(file, file?.SerializeDefaults());
		}

		internal static void WriteCurrentToDisk(YamlConfigFile file)
		{
			WriteRawToDisk(file, file?.SerializeCurrent());
		}

		internal static void WriteRawToDisk(YamlConfigFile file, string serializedYaml)
		{
			if (file == null || string.IsNullOrEmpty(file.Path))
			{
				return;
			}
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(file.Path));
				using (StreamWriter streamWriter = new StreamWriter(file.Path))
				{
					if (!string.IsNullOrEmpty(file.Header))
					{
						streamWriter.WriteLine(file.Header);
					}
					streamWriter.WriteLine(serializedYaml);
				}
				ConfigFileWatcher.RefreshStamp(file.Path);
			}
			catch (Exception ex)
			{
				Logger.LogError("Could not write " + file.FileName + ": " + ex.Message);
			}
		}

		internal static void RevalidateAll()
		{
			for (int i = 0; i < Files.Count; i++)
			{
				try
				{
					Files[i].Revalidate();
				}
				catch (Exception ex)
				{
					Logger.LogError("Revalidating " + Files[i].FileName + " threw: " + ex.Message);
				}
			}
		}

		internal static bool HasNoUsableConfig(string yamlText)
		{
			if (string.IsNullOrWhiteSpace(yamlText))
			{
				return true;
			}
			string[] array = yamlText.Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length != 0 && !text.StartsWith("#") && !(text == "---") && !(text == "..."))
				{
					return false;
				}
			}
			return true;
		}

		private static void Prepare(YamlConfigFile file)
		{
			try
			{
				file.Path = Path.Combine(ConfigDirectory(file.SubFolder), file.FileName);
				ByPath[file.Path] = file;
				if (!File.Exists(file.Path))
				{
					Logger.LogDebug(file.FileName + " missing, writing this mod's built-in defaults.");
					RestoreDefaults(file);
				}
				else if (HasNoUsableConfig(File.ReadAllText(file.Path)))
				{
					Logger.LogWarning(file.FileName + " was empty and has been overwritten with this mod's built-in defaults. File: " + file.Path);
					RestoreDefaults(file);
				}
				file.LoadFrom(File.Exists(file.Path) ? File.ReadAllText(file.Path) : "", ConfigOrigin.Startup);
				ConfigNetwork.RegisterFile(file);
				if (file.Watch)
				{
					ConfigFileWatcher.Register(file.Path, OnWatchedFileChanged);
				}
			}
			catch (Exception arg)
			{
				Logger.LogError($"Could not prepare {file.FileName}: {arg}");
			}
		}

		private static void OnWatchedFileChanged(string path)
		{
			if (ByPath.TryGetValue(path, out var file))
			{
				ConfigChangeDebouncer.Schedule(file, delegate
				{
					ReloadFromDisk(file);
				});
			}
		}
	}
	public enum ExampleMode
	{
		Off,
		Add,
		Multiply
	}
	public class ExampleEntry
	{
		public string DisplayName { get; set; }

		[DefaultValue(1f)]
		public float Multiplier { get; set; } = 1f;

		public ExampleMode Mode { get; set; }

		public List<string> Prefabs { get; set; } = new List<string>();
	}
	public class ExampleSettings
	{
		public int Version { get; set; } = 1;

		public Dictionary<string, ExampleEntry> Entries { get; set; } = new Dictionary<string, ExampleEntry>();
	}
	internal static class ExampleData
	{
		internal static ExampleSettings Current = new ExampleSettings();

		internal static Dictionary<string, int> SavedCounters = new Dictionary<string, int>();

		internal static Dictionary<string, ExampleEntry> LegacyEntries = new Dictionary<string, ExampleEntry>();

		internal static ExampleSettings BuildDefaults()
		{
			return new ExampleSettings
			{
				Version = 1,
				Entries = new Dictionary<string, ExampleEntry> { 
				{
					"Example",
					new ExampleEntry
					{
						DisplayName = "An example",
						Multiplier = 1.5f,
						Mode = ExampleMode.Multiply
					}
				} }
			};
		}

		internal static ValidationReport Validate(ExampleSettings next, ExampleSettings previous)
		{
			ValidationReport validationReport = new ValidationReport();
			if (next.Entries == null || next.Entries.Count == 0)
			{
				return validationReport.Error("it defines no entries");
			}
			foreach (KeyValuePair<string, ExampleEntry> entry in next.Entries)
			{
				if (entry.Value == null)
				{
					validationReport.Error("entry '" + entry.Key + "' has no settings under it");
					continue;
				}
				if (entry.Value.Multiplier < 0.1f || entry.Value.Multiplier > 10f)
				{
					validationReport.Warn($"entry '{entry.Key}' has Multiplier {entry.Value.Multiplier}, outside the " + "supported range of 0.1 - 10. It will be used as written.");
				}
				if (entry.Value.Prefabs == null)
				{
					continue;
				}
				foreach (string prefab in entry.Value.Prefabs)
				{
					if (PrefabManager.Instance != null && (Object)(object)PrefabManager.Instance.GetPrefab(prefab) == (Object)null)
					{
						validationReport.Warn("entry '" + entry.Key + "' names prefab '" + prefab + "', which does not exist. That prefab will be skipped.");
					}
				}
			}
			if (previous != null && previous.Entries != null)
			{
				foreach (string key in previous.Entries.Keys)
				{
					if (!next.Entries.ContainsKey(key))
					{
						validationReport.Warn("entry '" + key + "' was removed. Anything still referring to it will fall back.");
					}
				}
			}
			return validationReport;
		}
	}
	internal class TolerantEnumConverter : IYamlTypeConverter
	{
		private static readonly Dictionary<Type, object> fallbacks = new Dictionary<Type, object>();

		internal static void SetFallback(Type enumType, object fallback)
		{
			if (!(enumType == null) && enumType.IsEnum)
			{
				fallbacks[enumType] = fallback;
			}
		}

		public bool Accepts(Type type)
		{
			if (type != null)
			{
				return type.IsEnum;
			}
			return false;
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			//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)
			Scalar val = ParserExtensions.Consume<Scalar>(parser);
			string value = val.Value;
			if (!string.IsNullOrWhiteSpace(value))
			{
				try
				{
					return Enum.Parse(type, value.Trim(), ignoreCase: true);
				}
				catch (Exception)
				{
				}
			}
			object obj = FallbackFor(type);
			object[] array = new object[4];
			Mark start = ((ParsingEvent)val).Start;
			array[0] = ((Mark)(ref start)).Line;
			array[1] = value;
			array[2] = type.Name;
			array[3] = obj;
			Logger.LogWarning(string.Format("line {0}: '{1}' is not a valid {2}. Using {3}. ", array) + "Valid values: " + string.Join(", ", Enum.GetNames(type)) + ".");
			return obj;
		}

		public void WriteYaml(IEmitter emitter, object value, Type type, ObjectSerializer serializer)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			emitter.Emit((ParsingEvent)new Scalar((value == null) ? "" : value.ToString()));
		}

		private static object FallbackFor(Type type)
		{
			if (fallbacks.TryGetValue(type, out var value))
			{
				return value;
			}
			return Activator.CreateInstance(type);
		}
	}
	internal static class ConfigUI
	{
		internal class ConfigUIInputGuard : MonoBehaviour
		{
			private bool held;

			internal void Hold()
			{
				if (!held)
				{
					held = true;
					PushInputBlock();
				}
			}

			public void OnDestroy()
			{
				if (held)
				{
					held = false;
					PopInputBlock();
				}
			}
		}

		internal const float RowHeight = 34f;

		internal const float SubRowHeight = 26f;

		internal const float RowGap = 4f;

		internal const float CloseXSize = 28f;

		private static int inputBlockDepth;

		internal static void PushInputBlock()
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				inputBlockDepth++;
				if (inputBlockDepth == 1)
				{
					GUIManager.BlockInput(true);
				}
			}
		}

		internal static void PopInputBlock()
		{
			if (inputBlockDepth > 0)
			{
				inputBlockDepth--;
				if (inputBlockDepth == 0)
				{
					GUIManager.BlockInput(false);
				}
			}
		}

		internal static GameObject NewUI(string name, Transform parent, params Type[] components)
		{
			//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_000f: Expected O, but got Unknown
			GameObject val = new GameObject(name, components)
			{
				layer = 5
			};
			if ((Object)(object)val.GetComponent<RectTransform>() == (Object)null)
			{
				val.AddComponent<RectTransform>();
			}
			val.transform.SetParent(parent, false);
			return val;
		}

		internal static GameObject NewRect(string name, Transform parent, float x, float y, float w, float h)
		{
			//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_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_0045: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = NewUI(name, parent, typeof(RectTransform));
			RectTransform val = (RectTransform)obj.transform;
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(0f, 1f);
			val.pivot = new Vector2(0f, 1f);
			val.sizeDelta = new Vector2(w, h);
			val.anchoredPosition = new Vector2(x, 0f - y);
			return obj;
		}

		internal static GameObject NewRow(Transform parent, float width, float height)
		{
			return NewRect("Row", parent, 0f, 0f, width, height);
		}

		internal static GameObject NewLayoutRow(Transform content, float width, float height)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_006b: 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)
			GameObject obj = NewUI("LayoutRow", content, typeof(RectTransform), typeof(LayoutElement));
			RectTransform val = (RectTransform)obj.transform;
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(0f, 1f);
			val.pivot = new Vector2(0f, 1f);
			val.sizeDelta = new Vector2(width, height);
			LayoutElement component = obj.GetComponent<LayoutElement>();
			component.minHeight = height;
			component.preferredHeight = height;
			component.minWidth = width;
			component.preferredWidth = width;
			return obj;
		}

		internal static void LayoutColumn(List<GameObject> rows, float x, float startY, float gap = 4f)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0034: 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)
			float num = startY;
			foreach (GameObject row in rows)
			{
				if (!((Object)(object)row == (Object)null) && row.activeSelf)
				{
					RectTransform val = (RectTransform)row.transform;
					val.anchoredPosition = new Vector2(x, 0f - num);
					num += val.sizeDelta.y + gap;
				}
			}
		}

		internal static void PositionRow(GameObject row, float x, float y)
		{
			//IL_0010: 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)
			if (!((Object)(object)row == (Object)null))
			{
				((RectTransform)row.transform).anchoredPosition = new Vector2(x, 0f - y);
			}
		}

		internal static GameObject CreatePanel(string title, float w, float h, out Transform body)
		{
			//IL_0019: 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_0037: 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)
			GameObject val = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), w, h, true);
			val.AddComponent<ConfigUIInputGuard>().Hold();
			AddText(val.transform, 0f, 16f, w, 34f, title, 22, (TextAnchor)4, GUIManager.Instance.ValheimYellow);
			body = val.transform;
			return val;
		}

		internal static GameObject CreateScroll(Transform parent, float x, float y, float w, float h, out Transform content, out float contentWidth)
		{
			//IL_002d: 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)
			GameObject val = NewRect("ScrollHolder", parent, x, y, w, h);
			GameObject val2 = GUIManager.Instance.CreateScrollView(val.transform, false, true, 8f, 4f, GUIManager.Instance.ValheimScrollbarHandleColorBlock, new Color(0f, 0f, 0f, 0.5f), w, h);
			content = val2.transform.Find("Scroll View/Viewport/Content");
			contentWidth = w - 16f;
			ScrollRect componentInChildren = val2.GetComponentInChildren<ScrollRect>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.scrollSensitivity = 200f;
			}
			return val2;
		}

		internal static string L(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			if (Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize(text);
		}

		internal static Text AddText(Transform parent, float x, float y, float w, float h, string text, int fontSize, TextAnchor anchor, Color? color = null)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_0050: 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_0073: 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_0083: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GUIManager.Instance.CreateText(L(text), parent, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(x, 0f - y), GUIManager.Instance.AveriaSerifBold, fontSize, (Color)(((??)color) ?? GUIManager.Instance.ValheimBeige), true, Color.black, w, h, false);
			RectTransform val = (RectTransform)obj.transform;
			val.pivot = new Vector2(0f, 1f);
			val.anchoredPosition = new Vector2(x, 0f - y);
			Text component = obj.GetComponent<Text>();
			component.alignment = anchor;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			component.verticalOverflow = (VerticalWrapMode)0;
			return component;
		}

		internal static GameObject AddHeaderRow(Transform parent, float colWidth, string text, TextAnchor anchor = (TextAnchor)3)
		{
			//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)
			GameObject obj = NewRow(parent, colWidth, 34f);
			AddText(obj.transform, 0f, 0f, colWidth, 34f, text, 18, anchor, GUIManager.Instance.ValheimYellow);
			return obj;
		}

		internal static GameObject AddTextRow(Transform parent, float colWidth, float height, string text, int fontSize, Color color, TextAnchor anchor = (TextAnchor)0)
		{
			//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)
			GameObject obj = NewRow(parent, colWidth, height);
			AddText(obj.transform, 0f, 0f, colWidth, height, text, fontSize, anchor, color);
			return obj;
		}

		internal static GameObject AddSpacerRow(Transform parent, float colWidth, float height)
		{
			return NewRow(parent, colWidth, height);
		}

		internal static GameObject AddDividerRow(Transform parent, float colWidth, float height = 12f)
		{
			//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_0042: 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_0057: 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_006c: 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_007d: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = NewRow(parent, colWidth, height);
			GameObject obj = NewUI("Divider", val.transform, typeof(Image));
			RectTransform val2 = (RectTransform)obj.transform;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.sizeDelta = new Vector2(colWidth, 2f);
			val2.anchoredPosition = new Vector2(0f, 0f - height * 0.5f);
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = new Color(0.6f, 0.5f, 0.35f, 0.6f);
			((Graphic)component).raycastTarget = false;
			return val;
		}

		internal static void SetMessages(Text target, IList<string> errors, IList<string> warnings)
		{
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			List<string> list = new List<string>();
			if (errors != null)
			{
				foreach (string error in errors)
				{
					list.Add("<color=#F87171>" + error + "</color>");
				}
			}
			if (warnings != null)
			{
				foreach (string warning in warnings)
				{
					list.Add("<color=#FBBF24>" + warning + "</color>");
				}
			}
			target.text = string.Join("\n", list.ToArray());
		}

		internal static GameObject AddButton(Transform parent, float x, float y, float w, string text, UnityAction onClick, float h = 40f)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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)
			GameObject val = GUIManager.Instance.CreateButton(L(text), parent, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(x, 0f - y), w, h);
			RectTransform val2 = (RectTransform)val.transform;
			val2.pivot = new Vector2(0f, 1f);
			val2.anchoredPosition = new Vector2(x, 0f - y);
			if (onClick != null)
			{
				((UnityEvent)val.GetComponent<Button>().onClick).AddListener(onClick);
			}
			return val;
		}

		internal static GameObject AddCloseX(Transform panel, float panelWidth, UnityAction onClick)
		{
			return AddButton(panel, panelWidth - 28f - 16f, 12f, 28f, "X", onClick, 28f);
		}

		internal static Toggle AddToggle(Transform parent, float x, float y, float size, bool value, Action<bool> onChange)
		{
			//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_003e: 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_0053: 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_0068: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GUIManager.Instance.CreateToggle(parent, size, size);
			obj.transform.SetParent(parent, false);
			RectTransform val = (RectTransform)obj.transform;
			((Transform)val).localScale = Vector3.one;
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(0f, 1f);
			val.pivot = new Vector2(0f, 1f);
			val.anchoredPosition = new Vector2(x, 0f - y);
			Toggle component = obj.GetComponent<Toggle>();
			component.isOn = value;
			if (onChange != null)
			{
				((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)delegate(bool b)
				{
					onChange(b);
				});
			}
			return component;
		}

		internal static GameObject AddToggleRow(Transform parent, float colWidth, float labelW, string label, bool value, Action<bool> onChange, bool toggleOnLeft = false)
		{
			GameObject obj = NewRow(parent, colWidth, 34f);
			float x = (toggleOnLeft ? 0f : (labelW + 6f));
			float x2 = (toggleOnLeft ? 34f : 0f);
			AddText(obj.transform, x2, 0f, labelW, 34f, label, 15, (TextAnchor)3);
			AddToggle(obj.transform, x, 3f, 26f, value, onChange);
			return obj;
		}

		internal static string Fmt(float v, bool whole)
		{
			if (!whole)
			{
				return v.ToString("0.00");
			}
			return ((int)Mathf.Round(v)).ToString();
		}

		internal static Slider BuildSlider(Transform parent, float x, float y, float width, float min, float max, float value, bool wholeNumbers)
		{
			//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_0042: 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_0057: 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_006c: 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_007d: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_00e2: 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_00ed: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_01d6: 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_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: 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_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: 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_0297: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = NewUI("Slider", parent, typeof(RectTransform), typeof(Slider));
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.sizeDelta = new Vector2(width, 20f);
			val2.anchoredPosition = new Vector2(x, 0f - y);
			GameObject obj = NewUI("Background", val.transform, typeof(Image));
			RectTransform val3 = (RectTransform)obj.transform;
			val3.anchorMin = new Vector2(0f, 0.25f);
			val3.anchorMax = new Vector2(1f, 0.75f);
			val3.sizeDelta = Vector2.zero;
			val3.anchoredPosition = Vector2.zero;
			((Graphic)obj.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.6f);
			GameObject val4 = NewUI("Fill Area", val.transform, typeof(RectTransform));
			RectTransform val5 = (RectTransform)val4.transform;
			val5.anchorMin = new Vector2(0f, 0.25f);
			val5.anchorMax = new Vector2(1f, 0.75f);
			val5.sizeDelta = new Vector2(-20f, 0f);
			val5.anchoredPosition = Vector2.zero;
			GameObject obj2 = NewUI("Fill", val4.transform, typeof(Image));
			RectTransform val6 = (RectTransform)obj2.transform;
			val6.sizeDelta = new Vector2(10f, 0f);
			((Graphic)obj2.GetComponent<Image>()).color = new Color(0.7f, 0.6f, 0.4f, 0.9f);
			GameObject val7 = NewUI("Handle Slide Area", val.transform, typeof(RectTransform));
			RectTransform val8 = (RectTransform)val7.transform;
			val8.anchorMin = Vector2.zero;
			val8.anchorMax = Vector2.one;
			val8.sizeDelta = new Vector2(-20f, 0f);
			val8.anchoredPosition = Vector2.zero;
			GameObject obj3 = NewUI("Handle", val7.transform, typeof(Image));
			RectTransform val9 = (RectTransform)obj3.transform;
			val9.sizeDelta = new Vector2(20f, 0f);
			Image component = obj3.GetComponent<Image>();
			component.sprite = GUIManager.Instance.GetSprite("checkbox_marker");
			component.type = (Type)1;
			Slider component2 = val.GetComponent<Slider>();
			component2.fillRect = val6;
			component2.handleRect = val9;
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			component2.direction = (Direction)0;
			component2.minValue = min;
			component2.maxValue = max;
			component2.wholeNumbers = wholeNumbers;
			component2.value = Mathf.Clamp(value, min, max);
			GUIManager.Instance.ApplySliderStyle(component2);
			return component2;
		}

		internal static GameObject AddSliderRow(Transform parent, float colWidth, float labelW, float sliderW, float valueW, string label, float min, float max, float value, bool wholeNumbers, Action<float> onChange)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = NewRow(parent, colWidth, 34f);
			AddText(val.transform, 0f, 0f, labelW, 34f, label, 15, (TextAnchor)3);
			Slider slider = BuildSlider(val.transform, labelW, 7f, sliderW, min, max, value, wholeNumbers);
			float num = labelW + sliderW + 10f;
			GameObject val2 = GUIManager.Instance.CreateInputField(val.transform, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(num, -3f), (ContentType)(wholeNumbers ? 2 : 3), (string)null, 15, valueW, 28f);
			RectTransform val3 = (RectTransform)val2.transform;
			val3.pivot = new Vector2(0f, 1f);
			val3.anchoredPosition = new Vector2(num, -3f);
			InputField box = val2.GetComponent<InputField>();
			box.SetTextWithoutNotify(Fmt(slider.value, wholeNumbers));
			((UnityEvent<float>)(object)slider.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
			{
				if (wholeNumbers)
				{
					v = Mathf.Round(v);
				}
				box.SetTextWithoutNotify(Fmt(v, wholeNumbers));
				onChange?.Invoke(v);
			});
			((UnityEvent<string>)(object)box.onEndEdit).AddListener((UnityAction<string>)delegate(string str)
			{
				if (!float.TryParse(str, out var result))
				{
					result = slider.value;
				}
				result = Mathf.Clamp(result, min, max);
				if (wholeNumbers)
				{
					result = Mathf.Round(result);
				}
				box.SetTextWithoutNotify(Fmt(result, wholeNumbers));
				if (slider.value != result)
				{
					slider.value = result;
				}
				else
				{
					onChange?.Invoke(result);
				}
			});
			return val;
		}

		internal static InputField AddTextField(Transform parent, float x, float y, float w, string value, Action<string> onCommit, ContentType contentType = (ContentType)0, string placeholder = null, int charLimit = 0)
		{
			//IL_001e: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0061: 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)
			GameObject obj = GUIManager.Instance.CreateInputField(parent, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(x, 0f - y), contentType, placeholder, 15, w, 28f);
			RectTransform val = (RectTransform)obj.transform;
			val.pivot = new Vector2(0f, 1f);
			val.anchoredPosition = new Vector2(x, 0f - y);
			InputField component = obj.GetComponent<InputField>();
			if (charLimit > 0)
			{
				component.characterLimit = charLimit;
			}
			component.SetTextWithoutNotify(value ?? "");
			if (onCommit != null)
			{
				((UnityEvent<string>)(object)component.onEndEdit).AddListener((UnityAction<string>)delegate(string s)
				{
					onCommit(s);
				});
			}
			return component;
		}

		internal static GameObject AddTextFieldRow(Transform parent, float colWidth, float labelW, float fieldW, string label, string value, Action<string> onCommit, string placeholder = null, int charLimit = 0)
		{
			GameObject obj = NewRow(parent, colWidth, 34f);
			AddText(obj.transform, 0f, 0f, labelW, 34f, label, 15, (TextAnchor)3);
			AddTextField(obj.transform, labelW + 6f, 3f, fieldW, value, onCommit, (ContentType)0, placeholder, charLimit);
			return obj;
		}

		internal static GameObject AddEnumCycleRow(Transform parent, float colWidth, float labelW, float ctrlW, string label, string[] options, int currentIndex, Action<int> onChange)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			GameObject val = NewRow(parent, colWidth, 34f);
			AddText(val.transform, 0f, 0f, labelW, 34f, label, 15, (TextAnchor)3);
			int idx = Mathf.Clamp(currentIndex, 0, Math.Max(0, options.Length - 1));
			GameObject val2 = GUIManager.Instance.CreateButton((options.Length != 0) ? options[idx] : "", val.transform, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(labelW + 6f, -2f), ctrlW, 28f);
			RectTransform val3 = (RectTransform)val2.transform;
			val3.pivot = new Vector2(0f, 1f);
			val3.anchoredPosition = new Vector2(labelW + 6f, -2f);
			Text caption = val2.GetComponentInChildren<Text>();
			((UnityEvent)val2.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				if (options.Length != 0)
				{
					idx = (idx + 1) % options.Length;
					caption.text = options[idx];
					onChange?.Invoke(idx);
				}
			});
			return val;
		}

		internal static GameObject AddEnumFlagsRow(Transform parent, float colWidth, float labelW, string label, string[] names, Func<int, bool> isOn, Action<int, bool> set)
		{
			GameObject val = NewRow(parent, colWidth, 34f);
			AddText(val.transform, 0f, 0f, labelW, 34f, label, 15, (TextAnchor)3);
			float num = labelW + 6f;
			for (int i = 0; i < names.Length; i++)
			{
				int index = i;
				AddToggle(val.transform, num, 4f, 22f, isOn(index), delegate(bool on)
				{
					set(index, on);
				});
				AddText(val.transform, num + 26f, 0f, 90f, 34f, names[index], 13, (TextAnchor)3);
				num += 120f;
			}
			return val;
		}

		internal static GameObject AddPickerRow(Transform parent, float colWidth, float labelW, float ctrlW, string label, string current, Func<IList<string>> options, Action<string> onPick, Func<string, bool> isKnown = null)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			GameObject val = NewRow(parent, colWidth, 34f);
			AddText(val.transform, 0f, 0f, labelW, 34f, label, 15, (TextAnchor)3);
			float num = ctrlW - 40f;
			InputField field = AddTextField(val.transform, labelW + 6f, 3f, num, current, delegate(string s)
			{
				onPick?.Invoke(s);
			}, (ContentType)0);
			Text marker = AddText(val.transform, labelW + 6f + num + 44f, 0f, 20f, 34f, "", 15, (TextAnchor)3, (Color?)new Color(0.98f, 0.75f, 0.14f));
			Action refreshMarker = delegate
			{
				bool flag = isKnown != null && !string.IsNullOrEmpty(field.text) && !isKnown(field.text);
				marker.text = (flag ? "!" : "");
			};
			refreshMarker();
			((UnityEvent<string>)(object)field.onEndEdit).AddListener((UnityAction<string>)delegate
			{
				refreshMarker();
			});
			AddButton(val.transform, labelW + 6f + num + 4f, 3f, 34f, "...", (UnityAction)delegate
			{
				string title = label;
				IList<string> options2;
				if (options == null)
				{
					IList<string> list = new List<string>();
					options2 = list;
				}
				else
				{
					options2 = options();
				}
				ConfigUIPicker.ShowPicker(title, options2, field.text, delegate(string picked)
				{
					field.SetTextWithoutNotify(picked);
					refreshMarker();
					onPick?.Invoke(picked);
				});
			}, 28f);
			return val;
		}

		internal static GameObject AddStringListEditor(Transform content, float width, string label, List<string> items, Action onChanged, Func<IList<string>> options = null, Func<string, bool> isKnown = null)
		{
			//IL_0063: 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_00a5: Expected O, but got Unknown
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Expected O, but got Unknown
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Expected O, but got Unknown
			GameObject val = NewLayoutRow(content, width, 26f);
			AddText(val.transform, 0f, 0f, width - 90f, 26f, label, 14, (TextAnchor)3, GUIManager.Instance.ValheimOrange);
			AddButton(val.transform, width - 84f, 0f, 80f, "Add", (UnityAction)delegate
			{
				items.Add("");
				onChanged?.Invoke();
			}, 24f);
			for (int num = 0; num < items.Count; num++)
			{
				int index = num;
				GameObject val2 = NewLayoutRow(content, width, 26f);
				InputField field = AddTextField(val2.transform, 12f, 0f, width - 92f, items[index], delegate(string s)
				{
					items[index] = s;
				}, (ContentType)0);
				Text marker = AddText(val2.transform, width - 74f, 0f, 16f, 26f, "", 14, (TextAnchor)3, (Color?)new Color(0.98f, 0.75f, 0.14f));
				Action refreshMarker = delegate
				{
					bool flag = isKnown != null && !string.IsNullOrEmpty(field.text) && !isKnown(field.text);
					marker.text = (flag ? "!" : "");
				};
				refreshMarker();
				((UnityEvent<string>)(object)field.onEndEdit).AddListener((UnityAction<string>)delegate
				{
					refreshMarker();
				});
				if (options != null)
				{
					AddButton(val2.transform, width - 56f, 0f, 26f, "...", (UnityAction)delegate
					{
						ConfigUIPicker.ShowPicker(label, options(), field.text, delegate(string picked)
						{
							field.SetTextWithoutNotify(picked);
							items[index] = picked;
							refreshMarker();
						});
					}, 24f);
				}
				AddButton(val2.transform, width - 26f, 0f, 24f, "x", (UnityAction)delegate
				{
					items.RemoveAt(index);
					onChanged?.Invoke();
				}, 24f);
			}
			return val;
		}
	}
	internal static class ConfigUILauncher
	{
		private static Component cachedBroker;

		private static MethodInfo cachedRegister;

		private static MethodInfo cachedUnregister;

		private static bool loggedOwner;

		internal static bool IsAvailable => (Object)(object)Resolve() != (Object)null;

		internal static void Init()
		{
			Resolve();
		}

		internal static bool Register(string displayName, Action openPanel)
		{
			if (string.IsNullOrEmpty(displayName) || openPanel == null)
			{
				return false;
			}
			Component val = Resolve();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (cachedRegister == null)
			{
				Logger.LogError("The QuickConfig launcher on this machine has no compatible Register method; '" + displayName + "' will not appear in it.");
				return false;
			}
			try
			{
				cachedRegister.Invoke(val, new object[2] { displayName, openPanel });
				return true;
			}
			catch (Exception ex)
			{
				Logger.LogError("Could not register '" + displayName + "' with the QuickConfig launcher: " + ex.Message);
				return false;
			}
		}

		internal static void Unregister(string displayName)
		{
			if (string.IsNullOrEmpty(displayName))
			{
				return;
			}
			Component val = Resolve();
			if ((Object)(object)val == (Object)null || cachedUnregister == null)
			{
				return;
			}
			try
			{
				cachedUnregister.Invoke(val, new object[1] { displayName });
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Could not unregister '" + displayName + "' from the QuickConfig launcher: " + ex.Message);
			}
		}

		private static Component Resolve()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			if ((Object)(object)cachedBroker != (Object)null)
			{
				return cachedBroker;
			}
			cachedRegister = null;
			cachedUnregister = null;
			GameObject val = null;
			try
			{
				val = GameObject.Find("ModQuickConfigLauncher");
			}
			catch (Exception)
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				try
				{
					val = new GameObject("ModQuickConfigLauncher");
					Object.DontDestroyOnLoad((Object)(object)val);
					val.AddComponent<QuickConfigBroker>();
				}
				catch (Exception ex2)
				{
					Logger.LogError("Could not create the QuickConfig launcher: " + ex2.Message);
					return null;
				}
			}
			Component val2 = null;
			Component[] components = val.GetComponents<Component>();
			foreach (Component val3 in components)
			{
				if ((Object)(object)val3 != (Object)null && ((object)val3).GetType().Name == "QuickConfigBroker")
				{
					val2 = val3;
					break;
				}
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			Type type = ((object)val2).GetType();
			cachedRegister = type.GetMethod("Register", BindingFlags.Instance | BindingFlags.Public, null, new Type[2]
			{
				typeof(string),
				typeof(Action)
			}, null);
			cachedUnregister = type.GetMethod("Unregister", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
			if (!loggedOwner)
			{
				loggedOwner = true;
				int num = 1;
				try
				{
					PropertyInfo property = type.GetProperty("BrokerVersion", BindingFlags.Instance | BindingFlags.Public);
					if (property != null)
					{
						num = (int)property.GetValue(val2, null);
					}
				}
				catch (Exception)
				{
				}
				Logger.LogInfo($"QuickConfig launcher v{num} owned by " + $"{type.Assembly.GetName().Name}; this mod carries v{2}.");
				if (num < 2)
				{
					Logger.LogInfo("That copy is older than this one. Registration still works; the launcher UI is whatever the owning mod shipped.");
				}
			}
			cachedBroker = val2;
			return cachedBroker;
		}
	}
	internal static class ConfigUIPicker
	{
		private const float PanelW = 420f;

		private const float PanelH = 520f;

		private const float RowH = 30f;

		private const int MaxRows = 400;

		private static GameObject overlay;

		internal static bool IsOpen => (Object)(object)overlay != (Object)null;

		internal static void ShowPicker(string title, IList<string> options, string current, Action<string> onPick)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_00c4: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: 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_0132: Expected O, but got Unknown
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			Close();
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return;
			}
			List<string> all = new List<string>();
			if (options != null)
			{
				foreach (string option in options)
				{
					if (!string.IsNullOrEmpty(option))
					{
						all.Add(option);
					}
				}
			}
			all.Sort(StringComparer.OrdinalIgnoreCase);
			overlay = ConfigUI.NewUI("ConfigUIPickerOverlay", GUIManager.CustomGUIFront.transform, typeof(Image));
			RectTransform val = (RectTransform)overlay.transform;
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			((Graphic)overlay.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.35f);
			Button obj = overlay.AddComponent<Button>();
			((Selectable)obj).transition = (Transition)0;
			((UnityEvent)obj.onClick).AddListener(new UnityAction(Close));
			overlay.AddComponent<ConfigUI.ConfigUIInputGuard>().Hold();
			GameObject obj2 = GUIManager.Instance.CreateWoodpanel(overlay.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 420f, 520f, true);
			ConfigUI.AddText(obj2.transform, 0f, 14f, 420f, 30f, title, 18, (TextAnchor)4, GUIManager.Instance.ValheimYellow);
			InputField val2 = ConfigUI.AddTextField(obj2.transform, 16f, 52f, 320f, "", null, (ContentType)0, "Filter...");
			ConfigUI.AddButton(obj2.transform, 344f, 52f, 60f, "Close", new UnityAction(Close), 28f);
			ConfigUI.CreateScroll(obj2.transform, 16f, 92f, 388f, 404f, out var content, out var contentW);
			if ((Object)(object)content == (Object)null)
			{
				return;
			}
			Action<string> rebuild = null;
			rebuild = delegate(string needle)
			{
				//IL_0014: 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_00dd: Expected O, but got Unknown
				foreach (Transform item in content)
				{
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
				int num = 0;
				foreach (string item2 in all)
				{
					if (string.IsNullOrEmpty(needle) || item2.IndexOf(needle, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						if (num >= 400)
						{
							break;
						}
						num++;
						string picked = item2;
						ConfigUI.AddButton(ConfigUI.NewLayoutRow(content, contentW, 30f).transform, 0f, 0f, contentW, picked, (UnityAction)delegate
						{
							Close();
							onPick?.Invoke(picked);
						}, 28f);
					}
				}
				if (num == 0)
				{
					ConfigUI.AddText(ConfigUI.NewLayoutRow(content, contentW, 30f).transform, 4f, 0f, contentW, 30f, "No matches", 14, (TextAnchor)3);
				}
				else if (num >= 400)
				{
					ConfigUI.AddText(ConfigUI.NewLayoutRow(content, contentW, 30f).transform, 4f, 0f, contentW, 30f, $"... {all.Count - num} more, type to narrow", 13, (TextAnchor)3);
				}
			};
			((UnityEvent<string>)(object)val2.onValueChanged).AddListener((UnityAction<string>)delegate(string needle)
			{
				rebuild(needle);
			});
			rebuild("");
		}

		internal static void Close()
		{
			if (!((Object)(object)overlay == (Object)null))
			{
				Object.Destroy((Object)(object)overlay);
				overlay = null;
			}
		}
	}
	internal static class ConfigUIPrompt
	{
		private const float PanelW = 460f;

		private static GameObject overlay;

		internal static void Show(string title, string label, string initial, string warning, Action<string> onAccept)
		{
			//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_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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00ce: 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_010f: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			Close();
			if (GUIManager.Instance != null && !((Object)(object)GUIManager.CustomGUIFront == (Object)null))
			{
				bool flag = !string.IsNullOrEmpty(warning);
				float num = (flag ? 96f : 0f);
				float num2 = 190f + num;
				overlay = ConfigUI.NewUI("ConfigUIPromptOverlay", GUIManager.CustomGUIFront.transform, typeof(Image));
				RectTransform val = (RectTransform)overlay.transform;
				val.anchorMin = Vector2.zero;
				val.anchorMax = Vector2.one;
				val.offsetMin = Vector2.zero;
				val.offsetMax = Vector2.zero;
				((Graphic)overlay.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.45f);
				overlay.AddComponent<ConfigUI.ConfigUIInputGuard>().Hold();
				GameObject val2 = GUIManager.Instance.CreateWoodpanel(overlay.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 460f, num2, true);
				ConfigUI.AddText(val2.transform, 0f, 14f, 460f, 30f, title, 18, (TextAnchor)4, GUIManager.Instance.ValheimYellow);
				float num3 = 56f;
				if (flag)
				{
					ConfigUI.AddText(val2.transform, 20f, num3, 420f, num - 8f, warning, 13, (TextAnchor)0, (Color?)new Color(0.98f, 0.75f, 0.14f));
					num3 += num;
				}
				ConfigUI.AddText(val2.transform, 20f, num3, 120f, 28f, label, 15, (TextAnchor)3);
				InputField field = ConfigUI.AddTextField(val2.transform, 140f, num3, 300f, initial, null, (ContentType)0, null, 64);
				num3 += 46f;
				ConfigUI.AddButton(val2.transform, 20f, num3, 190f, "Cancel", new UnityAction(Close), 34f);
				ConfigUI.AddButton(val2.transform, 250f, num3, 190f, "OK", (UnityAction)delegate
				{
					string text = field.text;
					Close();
					onAccept?.Invoke(text);
				}, 34f);
				((Selectable)field).Select();
				field.ActivateInputField();
			}
		}

		internal static void Close()
		{
			if (!((Object)(object)overlay == (Object)null))
			{
				Object.Destroy((Object)(object)overlay);
				overlay = null;
			}
		}
	}
	internal static class ExampleConfigPanel
	{
		private const string EntryName = "CommunityPatchExtras";

		private const float PanelW = 620f;

		private const float PanelH = 520f;

		private const float LabelW = 190f;

		private static GameObject panel;

		private static ExampleSettings staged;

		private static Text messages;

		internal static void Init()
		{
			ConfigUILauncher.Init();
			ApplyRegistration();
		}

		internal static void ApplyRegistration()
		{
			if (ValConfig.ShowQuickConfigButton == null || ValConfig.ShowQuickConfigButton.Value)
			{
				ConfigUILauncher.Register("CommunityPatchExtras", OpenPanel);
			}
			else
			{
				ConfigUILauncher.Unregister("CommunityPatchExtras");
			}
		}

		internal static void OpenPanel()
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Expected O, but got Unknown
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Expected O, but got Unknown
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Expected O, but got Unknown
			ClosePanel();
			YamlConfigFile<ExampleSettings> exampleFile = YamlConfigManager.ExampleFile;
			if (exampleFile == null)
			{
				return;
			}
			staged = exampleFile.EffectiveFormat.Deserializer.Deserialize<ExampleSettings>(exampleFile.EffectiveFormat.Serializer.Serialize((object)exampleFile.Value));
			if (staged == null)
			{
				staged = ExampleData.BuildDefaults();
			}
			panel = ConfigUI.CreatePanel("Example settings", 620f, 520f, out var body);
			List<GameObject> list = new List<GameObject>();
			list.Add(ConfigUI.AddHeaderRow(body, 580f, "Entries", (TextAnchor)3));
			foreach (KeyValuePair<string, ExampleEntry> entry2 in staged.Entries)
			{
				ExampleEntry entry = entry2.Value;
				list.Add(ConfigUI.AddTextRow(body, 580f, 26f, entry2.Key, 15, GUIManager.Instance.ValheimOrange, (TextAnchor)0));
				list.Add(ConfigUI.AddTextFieldRow(body, 580f, 190f, 240f, "Display name", entry.DisplayName, delegate(string s)
				{
					entry.DisplayName = s;
				}, null, 64));
				list.Add(ConfigUI.AddSliderRow(body, 580f, 190f, 200f, 60f, "Multiplier", 0.1f, 10f, entry.Multiplier, wholeNumbers: false, delegate(float v)
				{
					entry.Multiplier = v;
				}));
				list.Add(ConfigUI.AddEnumCycleRow(body, 580f, 190f, 150f, "Mode", Enum.GetNames(typeof(ExampleMode)), (int)entry.Mode, delegate(int i)
				{
					entry.Mode = (ExampleMode)i;
				}));
				list.Add(ConfigUI.AddPickerRow(body, 580f, 190f, 260f, "First prefab", (entry.Prefabs.Count > 0) ? entry.Prefabs[0] : "", PrefabNames, delegate(string s)
				{
					if (entry.Prefabs.Count > 0)
					{
						entry.Prefabs[0] = s;
					}
					else
					{
						entry.Prefabs.Add(s);
					}
				}, IsKnownPrefab));
				list.Add(ConfigUI.AddDividerRow(body, 580f));
			}
			ConfigUI.LayoutColumn(list, 20f, 60f);
			messages = ConfigUI.AddText(body, 20f, 412f, 580f, 46f, "", 13, (TextAnchor)0);
			ConfigUI.AddButton(body, 20f, 464f, 130f, "Validate", new UnityAction(Validate));
			ConfigUI.AddButton(body, 300f, 464f, 130f, "Cancel", new UnityAction(ClosePanel));
			ConfigUI.AddButton(body, 450f, 464f, 150f, "Apply & Save", new UnityAction(ApplyAndSave));
		}

		private static void Validate()
		{
			YamlConfigFile<ExampleSettings> exampleFile = YamlConfigManager.ExampleFile;
			if (exampleFile != null && staged != null)
			{
				string parseError;
				ValidationReport validationReport = exampleFile.DryRun(YamlConfigManager.SerializeForEdit(exampleFile, staged), out parseError);
				if (parseError != null)
				{
					ConfigUI.SetMessages(messages, new List<string> { parseError }, null);
				}
				else if (validationReport.Errors.Count == 0 && validationReport.Warnings.Count == 0)
				{
					messages.text = "Looks good.";
				}
				else
				{
					ConfigUI.SetMessages(messages, validationReport.Errors, validationReport.Warnings);
				}
			}
		}

		private static void ApplyAndSave()
		{
			YamlConfigFile<ExampleSettings> exampleFile = YamlConfigManager.ExampleFile;
			if (exampleFile == null || staged == null)
			{
				return;
			}
			try
			{
				string yaml = YamlConfigManager.SerializeForEdit(exampleFile, staged);
				if (!YamlConfigManager.ApplyEdited(exampleFile, yaml, out var message))
				{
					ConfigUI.SetMessages(messages, new List<string> { message }, null);
				}
				else
				{
					ClosePanel();
				}
			}
			catch (Exception ex)
			{
				Logger.LogError($"Example config panel failed to apply: {ex}");
				ConfigUI.SetMessages(messages, new List<string> { ex.Message }, null);
			}
		}

		private static void ClosePanel()
		{
			if (!((Object)(object)panel == (Object)null))
			{
				Object.Destroy((Object)(object)panel);
				panel = null;
				messages = null;
			}
		}

		private static IList<string> PrefabNames()
		{
			List<string> list = new List<string>();
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return list;
			}
			foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
			{
				if ((Object)(object)prefab != (Object)null)
				{
					list.Add(((Object)prefab).name);
				}
			}
			return list;
		}

		private static bool IsKnownPrefab(string name)
		{
			if (PrefabManager.Instance == null)
			{
				return true;
			}
			return (Object)(object)PrefabManager.Instance.GetPrefab(name) != (Object)null;
		}
	}
	internal class QuickConfigBroker : MonoBehaviour
	{
		internal const string BrokerObjectName = "ModQuickConfigLauncher";

		internal const string BrokerTypeName = "QuickConfigBroker";

		internal const string ButtonObjectName = "ModQuickConfigButton";

		internal const int ContractVersion = 2;

		private const float ButtonW = 150f;

		private const float ButtonH = 38f;

		private const float PanelW = 320f;

		private static QuickConfigBroker Instance;

		private static Harmony harmony;

		private readonly Dictionary<string, Action> entries = new Dictionary<string, Action>(StringComparer.Ordinal);

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

		private GameObject mainMenuButton;

		private GameObject pauseButton;

		private GameObject listPanel;

		public int BrokerVersion => 2;

		public void Register(string modName, Action openPanel)
		{
			if (!string.IsNullOrEmpty(modName) && openPanel != null)
			{
				if (!entries.ContainsKey(modName))
				{
					order.Add(modName);
				}
				entries[modName] = openPanel;
				RefreshVisibility();
			}
		}

		public void Unregister(string modName)
		{
			if (!string.IsNullOrEmpty(modName))
			{
				if (entries.Remove(modName))
				{
					order.Remove(modName);
				}
				if ((Object)(object)listPanel != (Object)null)
				{
					CloseList();
				}
				RefreshVisibility();
			}
		}

		public bool IsRegistered(string modName)
		{
			if (!string.IsNullOrEmpty(modName))
			{
				return entries.ContainsKey(modName);
			}
			return false;
		}

		public void Awake()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			Instance = this;
			GUIManager.OnCustomGUIAvailable += OnCustomGUIAvailable;
			SynchronizationManager.OnAdminStatusChanged += OnAdminStatusChanged;
			SynchronizationManager.OnConfigurationSynchronized += OnConfigurationSynchronized;
			try
			{
				if (harmony == null)
				{
					harmony = new Harmony("ModQuickConfigLauncher.broker");
					harmony.Patch((MethodBase)AccessTools.Method(typeof(Menu), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(QuickConfigBroker), "OnMenuStart", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					harmony.Patch((MethodBase)AccessTools.Method(typeof(Menu), "Update", (Type[])null, (Type[])null), new HarmonyMethod(typeof(QuickConfigBroker), "OnMenuUpdate", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning("QuickConfig launcher could not patch Menu: " + ex.Message);
			}
			TryBuildButtons();
		}

		public void OnDestroy()
		{
			GUIManager.OnCustomGUIAvailable -= OnCustomGUIAvailable;
			SynchronizationManager.OnAdminStatusChanged -= OnAdminStatusChanged;
			SynchronizationManager.OnConfigurationSynchronized -= OnConfigurationSynchronized;
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private void OnAdminStatusChanged()
		{
			RefreshVisibility();
		}

		private void OnConfigurationSynchronized(object sender, EventArgs e)
		{
			RefreshVisibility();
		}

		private static void OnMenuStart(Menu __instance)
		{
			if (!((Object)(object)Instance == (Object)null))
			{
				Instance.EnsurePauseButton(__instance);
			}
		}

		private static bool OnMenuUpdate()
		{
			if ((Object)(object)Instance == (Object)null || (Object)(object)Instance.listPanel == (Object)null)
			{
				return true;
			}
			if (!ZInput.GetKeyDown((KeyCode)27, true))
			{
				return true;
			}
			Instance.CloseList();
			return false;
		}

		public void Update()
		{
			if (!((Object)(object)listPanel == (Object)null) && !((Object)(object)Menu.instance != (Object)null) && Input.GetKeyDown((KeyCode)27))
			{
				CloseList();
			}
		}

		private void OnCustomGUIAvailable()
		{
			TryBuildButtons();
		}

		private void TryBuildButtons()
		{
			if (!GUIManager.IsHeadless() && GUIManager.Instance != null)
			{
				if ((Object)(object)FejdStartup.instance != (Object)null && (Object)(object)GUIManager.CustomGUIFront != (Object)null)
				{
					mainMenuButton = EnsureCornerButton(mainMenuButton, GUIManager.CustomGUIFront.transform);
				}
				if ((Object)(object)Menu.instance != (Object)null)
				{
					EnsurePauseButton(Menu.instance);
				}
				RefreshVisibility();
			}
		}

		private void EnsurePauseButton(Menu menu)
		{
			if (!((Object)(object)menu == (Object)null) && !((Object)(object)menu.m_root == (Object)null))
			{
				pauseButton = EnsureCornerButton(pauseButton, menu.m_root);
				RefreshVisibility();
			}
		}

		private GameObject EnsureCornerButton(GameObject existing, Transform parent)
		{
			//IL_006d: 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_008b: 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_00b5: 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_00d4: 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_00fa: Expected O, but got Unknown
			if (GUIManager.IsHeadless() || GUIManager.Instance == null || (Object)(object)parent == (Object)null)
			{
				return existing;
			}
			if ((Object)(object)existing != (Object)null && (Object)(object)existing.transform.parent == (Object)(object)parent)
			{
				return existing;
			}
			Transform val = parent.Find("ModQuickConfigButton");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			GameObject obj = GUIManager.Instance.CreateButton(ConfigUI.L("Mod Config"), parent, new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(-20f, 20f), 150f, 38f);
			((Object)obj).name = "ModQuickConfigButton";
			RectTransform val2 = (RectTransform)obj.transform;
			val2.pivot = new Vector2(1f, 0f);
			val2.anchoredPosition = new Vector2(-20f, 20f);
			((UnityEvent)obj.GetComponent<Button>().onClick).AddListener(new UnityAction(OpenList));
			return obj;
		}

		private static bool CanConfigure()
		{
			if (GUIManager.IsHeadless() || GUIManager.Instance == null)
			{
				return false;
			}
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return true;
			}
			if (ZNet.instance.IsServer())
			{
				return true;
			}
			if (SynchronizationManager.Instance != null)
			{
				return SynchronizationManager.Instance.PlayerIsAdmin;
			}
			return false;
		}

		private void RefreshVisibility()
		{
			bool flag = entries.Count > 0 && CanConfigure();
			if ((Object)(object)mainMenuButton != (Object)null)
			{
				mainMenuButton.SetActive(flag && (Object)(object)FejdStartup.instance != (Object)null);
			}
			if ((Object)(object)pauseButton != (Object)null)
			{
				pauseButton.SetActive(flag);
			}
			if (!flag && (Object)(object)listPanel != (Object)null)
			{
				CloseList();
			}
		}

		private void OpenList()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			CloseList();
			if (!CanConfigure())
			{
				return;
			}
			if (order.Count == 1)
			{
				Invoke(order[0]);
				return;
			}
			float h = Mathf.Clamp(80f + 42f * (float)order.Count, 122f, 560f);
			listPanel = ConfigUI.CreatePanel("Configure a mod", 320f, h, out var body);
			ConfigUI.AddCloseX(body, 320f, new UnityAction(CloseList));
			float num = 64f;
			foreach (string item in order)
			{
				string entry = item;
				ConfigUI.AddButton(body, 20f, num, 280f, entry, (UnityAction)delegate
				{
					CloseList();
					Invoke(entry);
				});
				num += 42f;
			}
		}

		private void CloseList()
		{
			if (!((Object)(object)listPanel == (Object)null))
			{
				Object.Destroy((Object)(object)listPanel);
				listPanel = null;
			}
		}

		private void Invoke(string modName)
		{
			if (!entries.TryGetValue(modName, out var value) || value == null)
			{
				return;
			}
			try
			{
				value();
			}
			catch (Exception arg)
			{
				Logger.LogError($"The config panel for '{modName}' failed to open: {arg}");
			}
		}
	}
	internal enum ConfigOrigin
	{
		Startup,
		LocalFile,
		ServerSync,
		Api
	}
	internal enum ConfigFailurePolicy
	{
		KeepLastGood,
		RevertToDefaults,
		RestoreFileOnDisk
	}
	internal enum ConfigSyncMode
	{
		ServerAuthoritative,
		LocalOnly
	}
	internal enum UnknownKeyPolicy
	{
		WarnAndContinue,
		Strict,
		Silent
	}
	internal abstract class YamlConfigFile
	{
		internal string FileName { get; set; }

		internal string SubFolder { get; set; }

		internal string Header { get; set; }

		internal string RpcName { get; set; }

		internal YamlFormat Format { get; set; }

		internal ConfigFailurePolicy OnFailure { get; set; }

		internal ConfigSyncMode Sync { get; set; }

		internal UnknownKeyPolicy UnknownKeys { get; set; }

		internal bool ClientWritesToDisk { get; set; }

		internal bool Watch { get; set; } = true;

		internal bool NeedsPrefabs { get; set; }

		internal int SchemaVersion { get; set; }

		internal bool AllowAdminEdit { get; set; }

		internal string Path { get; set; }

		internal CustomRPC Rpc { get; set; }

		internal CustomRPC EditRpc { get; set; }

		internal bool LastLoadFailed { get; set; }

		internal string LastError { get; set; }

		internal DateTime LastLoadedUtc { get; set; }

		internal ValidationReport LastReport { get; set; }

		internal YamlFormat EffectiveFormat => Format ?? YamlFormat.Default;

		internal abstract Type ValueType { get; }

		internal abstract string SerializeDefaults();

		internal abstract string SerializeCurrent();

		internal abstract bool LoadFrom(string yaml, ConfigOrigin origin);

		internal abstract ValidationReport Revalidate();

		internal abstract ValidationReport DryRun(string yaml, out string parseError);
	}
	internal sealed class YamlConfigFile<T> : YamlConfigFile where T : class
	{
		internal Func<T> Defaults { get; set; }

		internal Action<T> Apply { get; set; }

		internal Func<T, T, ValidationReport> Validate { get; set; }

		internal Func<T, T> Migrate { get; set; }

		internal Func<T, int> GetSchemaVersion { get; set; }

		internal Action<T, int> SetSchemaVersion { get; set; }

		internal Func<T, bool> MigrateInPlace { get; set; }

		internal T Value { get; private set; }

		internal override Type ValueType => typeof(T);

		internal YamlConfigFile(string fileName)
		{
			base.FileName = fileName;
		}

		internal override string SerializeDefaults()
		{
			T val = BuildDefaults();
			if (val != null)
			{
				return base.EffectiveFormat.Serializer.Serialize((object)val);
			}
			return "";
		}

		internal override string SerializeCurrent()
		{
			if (Value != null)
			{
				return base.EffectiveFormat.Serializer.Serialize((object)Value);
			}
			return SerializeDefaults();
		}

		internal override ValidationReport DryRun(string yaml, out string parseError)
		{
			parseError = null;
			if (YamlConfigManager.HasNoUsableConfig(yaml))
			{
				parseError = "it is empty or contains only comments";
				return new ValidationReport();
			}
			string reason;
			T val = Deserialize(yaml, out reason);
			if (val == null)
			{
				parseError = reason ?? "it could not be parsed";
				return new ValidationReport();
			}
			if (MigrateInPlace != null)
			{
				try
				{
					MigrateInPlace(val);
				}
				catch (Exception ex)
				{
					Logger.LogWarning(base.FileName + " migration threw during a dry run: " + ex.Message);
				}
			}
			if (Validate == null)
			{
				return new ValidationReport();
			}
			try
			{
				return Validate(val, Value) ?? new ValidationReport();
			}
			catch (Exception ex2)
			{
				return new ValidationReport().Error("the validator threw: " + ex2.Message);
			}
		}

		internal override ValidationReport Revalidate()
		{
			if (Validate == null || Value == null)
			{
				return new ValidationReport();
			}
			ValidationReport validationReport;
			try
			{
				validationReport = Validate(Value, Value) ?? new ValidationReport();
			}
			catch (Exception ex)
			{
				validationReport = new ValidationReport().Error("the validator threw: " + ex.Message);
			}
			base.LastReport = validationReport;
			LogReport(validationReport);
			return validationReport;
		}

		internal override bool LoadFrom(string yaml, ConfigOrigin origin)
		{
			T parsed = null;
			string reason;
			if (YamlConfigManager.HasNoUsableConfig(yaml))
			{
				reason = "it is empty or contains only comments";
			}
			else
			{
				parsed = Deserialize(yaml, out reason);
			}
			if (parsed == null)
			{
				return Fail(reason, origin);
			}
			bool changed = false;
			if (base.SchemaVersion > 0 && GetSchemaVersion != null && !ApplySchemaVersion(ref parsed, out var problem, out changed))
			{
				return Fail(problem, origin);
			}
			if (MigrateInPlace != null)
			{
				try
				{
					if (MigrateInPlace(parsed))
					{
						changed = true;
					}
				}
				catch (Exception ex)
				{
					Logger.LogWarning(base.FileName + " migration threw, the file was left as it is: " + ex.Message);
				}
			}
			ValidationReport validationReport = new ValidationReport();
			if (Validate != null)
			{
				try
				{
					validationReport = Validate(parsed, Value) ?? new ValidationReport();
				}
				catch (Exception ex2)
				{
					validationReport = new ValidationReport().Error("the validator threw: " + ex2.Message);
				}
			}
			base.LastReport = validationReport;
			LogReport(validationReport);
			if (validationReport.HasErrors)
			{
				return Fail(string.Join(" ", validationReport.Errors.ToArray()), origin);
			}
			Value = parsed;
			base.LastLoadFailed = false;
			base.LastError = null;
			base.LastLoadedUtc = DateTime.UtcNow;
			Publish();
			if (changed && origin != ConfigOrigin.ServerSync && ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer()))
			{
				Logger.LogInfo(base.FileName + " was migrated to the current format; rewriting it.");
				YamlConfigManager.WriteCurrentToDisk(this);
			}
			return true;
		}

		private T Deserialize(string yaml, out string reason)
		{
			//IL_00a6: Expected O, but got Unknown
			//IL_002c: Expected O, but got Unknown
			reason = null;
			YamlFormat effectiveFormat = base.EffectiveFormat;
			try
			{
				T val = effectiveFormat.Deserializer.Deserialize<T>(yaml);
				if (val == null)
				{
					reason = "it is empty or contains only comments";
				}
				return val;
			}
			catch (YamlException ex)
			{
				YamlException e = ex;
				if (base.UnknownKeys == UnknownKeyPolicy.Strict)
				{
					reason = Describe(e);
					return null;
				}
				try
				{
					T val2 = effectiveFormat.TolerantDeserializer.Deserialize<T>(yaml);
					if (val2 == null)
					{
						reason = "it is empty or contains only comments";
						return null;
					}
					if (base.UnknownKeys == UnknownKeyPolicy.WarnAndContinue)
					{
						Logger.LogWarning(base.FileName + " " + Describe(e) + " That setting was ignored; the rest of the file loaded normally.");
					}
					return val2;
				}
				catch (YamlException ex2)
				{
					YamlException e2 = ex2;
					reason = Describe(e2);
					return null;
				}
			}
			catch (Exception ex3)
			{
				reason = ex3.Message;
				return null;
			}
		}

		private bool ApplySchemaVersion(ref T parsed, out string problem, out bool changed)
		{
			problem = null;
			changed = false;
			int num;
			try
			{
				num = GetSchemaVersion(parsed);
			}
			catch (Exception ex)
			{
				problem = "the schema version could not be read: " + ex.Message;
				return false;
			}
			if (num == base.SchemaVersion)
			{
				return true;
			}
			if (Migrate == null)
			{
				problem = $"it is schema version {num} but this mod expects {base.SchemaVersion}, and there is no migration for it";
				return false;
			}
			T val;
			try
			{
				val = Migrate(parsed);
			}
			catch (Exception ex2)
			{
				problem = $"migrating from schema version {num} to {base.SchemaVersion} threw: {ex2.Message}";
				return false;
			}
			if (val == null)
			{
				problem = $"migrating from schema version {num} to {base.SchemaVersion} produced nothing";
				return false;
			}
			parsed = val;
			SetSchemaVersion?.Invoke(parsed, base.SchemaVersion);
			changed = true;
			Logger.LogInfo($"{base.FileName} migrated from schema version {num} to {base.SchemaVersion}.");
			return true;
		}

		private bool Fail(string reason, ConfigOrigin origin)
		{
			base.LastLoadFailed = true;
			base.LastError = reason;
			switch (base.OnFailure)
			{
			case ConfigFailurePolicy.RevertToDefaults:
				PublishDefaults();
				Logger.LogError(base.FileName + " could not be loaded because " + reason + ". This mod's built-in defaults are in use; your file was left alone.");
				break;
			case ConfigFailurePolicy.RestoreFileOnDisk:
				PublishDefaults();
				if (origin != ConfigOrigin.ServerSync && ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer()))
				{
					YamlConfigManager.RestoreDefaults(this);
					Logger.LogError(base.FileName + " could not be loaded because " + reason + ". It has been overwritten with this mod's built-in defaults.");
				}
				else
				{
					Logger.LogError(base.FileName + " could not be loaded because " + reason + ". This mod's built-in defaults are in use; the file was left alone because this machine does not own it.");
				}
				break;
			default:
				if (Value == null)
				{
					PublishDefaults();
					Logger.LogError(base.FileName + " could not be loaded because " + reason + ". Nothing had loaded successfully yet, so this mod's built-in defaults are in use; your file was left alone.");
				}
				else
				{
					Logger.LogError(base.FileName + " could not be loaded because " + reason + ". The values that last loaded cleanly are still in use; your file was left alone.");
				}
				break;
			}
			return false;
		}

		private void PublishDefaults()
		{
			T val = BuildDefaults();
			if (val != null)
			{
				Value = val;
				Publish();
			}
		}

		private void Publish()
		{
			try
			{
				Apply?.Invoke(Value);
			}
			catch (Exception arg)
			{
				Logger.LogError($"{base.FileName} apply hook threw, the mod may be in a half-configured state: {arg}");
			}
		}

		private T BuildDefaults()
		{
			if (Defaults == null)
			{
				return null;
			}
			try
			{
				return Defaults();
			}
			catch (Exception arg)
			{
				Logger.LogError($"{base.FileName} default factory threw: {arg}");
				return null;
			}
		}

		private void LogReport(ValidationReport report)
		{
			if (report != null)
			{
				for (int i = 0; i < report.Warnings.Count; i++)
				{
					Logger.LogWarning(base.FileName + ": " + report.Warnings[i]);
				}
			}
		}

		private static string Describe(YamlException e)
		{
			//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)
			string arg = ((((Exception)(object)e).InnerException != null) ? ((Exception)(object)e).InnerException.Message : ((Exception)(object)e).Message);
			Mark start = e.Start;
			return $"line {((Mark)(ref start)).Line}: {arg}";
		}
	}
	internal sealed class YamlFormat
	{
		private readonly Action<SerializerBuilder> configureSerializer;

		private readonly Action<DeserializerBuilder> configureDeserializer;

		private static readonly List<YamlFormat> built;

		private static readonly List<IYamlTypeConverter> converters;

		internal ISerializer Serializer { get; private set; }

		internal IDeserializer Deserializer { get; private set; }

		internal IDeserializer TolerantDeserializer { get; private set; }

		internal static YamlFormat Default { get; private set; }

		internal static YamlFormat CamelCase { get; private set; }

		internal static YamlFormat JsonCompat { get; private set; }

		static YamlFormat()
		{
			built = new List<YamlFormat>();
			converters = new List<IYamlTypeConverter>();
			Default = Build(delegate(SerializerBuilder s)
			{
				((BuilderSkeleton<SerializerBuilder>)(object)s).WithNamingConvention(PascalCaseNamingConvention.Instance);
			}, null);
			CamelCase = Build(delegate(SerializerBuilder s)
			{
				((BuilderSkeleton<SerializerBuilder>)(object)s).WithNamingConvention(CamelCaseNamingConvention.Instance);
			}, null);
			JsonCompat = Build(delegate(SerializerBuilder s)
			{
				((BuilderSkeleton<SerializerBuilder>)(object)s).WithNamingConvention(PascalCaseNamingConvention.Instance).JsonCompatible();
			}, null);
		}

		private YamlFormat(Action<SerializerBuilder> serializerSetup, Action<DeserializerBuilder> deserializerSetup)
		{
			configureSerializer = serializerSetup;
			configureDeserializer = deserializerSetup;
			Rebuild();
		}

		internal static YamlFormat Build(Action<SerializerBuilder> configureSerializer, Action<DeserializerBuilder> configureDeserializer)
		{
			YamlFormat yamlFormat = new YamlFormat(configureSerializer, configureDeserializer);
			built.Add(yamlFormat);
			return yamlFormat;
		}

		internal static void AddTypeConverter(IYamlTypeConverter converter)
		{
			if (converter != null)
			{
				converters.Add(converter);
				for (int i = 0; i < built.Count; i++)
				{
					built[i].Rebuild();
				}
			}
		}

		private void Rebuild()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			SerializerBuilder val = new SerializerBuilder().DisableAliases().ConfigureDefaultValuesHandling((DefaultValuesHandling)2);
			configureSerializer?.Invoke(val);
			for (int i = 0; i < converters.Count; i++)
			{
				((BuilderSkeleton<SerializerBuilder>)(object)val).WithTypeConverter(converters[i]);
			}
			Serializer = val.Build();
			Deserializer = BuildDeserializer(tolerant: false);
			TolerantDeserializer = BuildDeserializer(tolerant: true);
		}

		private IDeserializer BuildDeserializer(bool tolerant)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			DeserializerBuilder val = new DeserializerBuilder().WithCaseInsensitivePropertyMatching();
			if (tolerant)
			{
				val.IgnoreUnmatchedProperties();
			}
			configureDeserializer?.Invoke(val);
			for (int i = 0; i < converters.Count; i++)
			{
				((BuilderSkeleton<DeserializerBuilder>)(object)val).WithTypeConverter(converters[i]);
			}
			return val.Build();
		}
	}
	internal class Logger
	{
		public static LogLevel Level = (LogLevel)16;

		public static void EnableDebugLogging(object sender, EventArgs e)
		{
			CheckEnableDebugLogging();
		}

		public static void CheckEnableDebugLogging()
		{
			//IL_0016: 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)
			if (ValConfig.EnableDebugMode.Value)
			{
				Level = (LogLevel)32;
			}
			else
			{
				Level = (LogLevel)16;
			}
		}

		public static void SetDebugLogging(bool state)
		{
			//IL_000d: 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)
			if (state)
			{
				Level = (LogLevel)32;
			}
			else
			{
				Level = (LogLevel)16;
			}
		}

		public static void LogDebug(string message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)Level >= 32)
			{
				CommunityPatchExtras.Log.LogInfo((object)("[DEBUG]" + message));
			}
		}

		public static void LogInfo(string message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)Level >= 16)
			{
				CommunityPatchExtras.Log.LogInfo((object)message);
			}
		}

		public static void LogWarning(string message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)Level >= 4)
			{
				CommunityPatchExtras.Log.LogWarning((object)message);
			}
		}

		public static void LogError(string message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)Level >= 2)
			{
				CommunityPatchExtras.Log.LogError((object)message);
			}
		}
	}
	internal static class TerminalManager
	{
		internal const string CommandPrefix = "jms";

		internal static readonly Dictionary<string, ModCommand> Registry = new Dictionary<string, ModCommand>();

		private static Terminal responseTerminal;

		private static bool initialized;

		private static Harmony harmony;

		private static void RegisterCommands()
		{
			RegisterHelpCommand();
			RegisterExampleCommands();
		}

		private static void RegisterExampleCommands()
		{
			new ModCommand("jms-echo", "Format: [info/detail/warning/error] [message] Prints a message back at the given severity.", Echo, "demo", EchoOptions, false, false, false, false, null, "jms-e");
			new ModCommand("jms-nearby", "Format: [optional: radius] Counts the creatures around you.", Nearby, "demo", TerminalArgs.RadiusPresets, false, false, false, false, null);
			new ModCommand("jms-worldinfo", "Reports server-side world state. Admins can run this from a connected client.", WorldInfo, "world", null, false, true, true, false, null);
		}

		private static List<string> EchoOptions(string[] input)
		{
			if (input.Length > 2)
			{
				return new List<string>();
			}
			return TerminalArgs.Names<OutputLevel>();
		}

		private static void Echo(ModCommandArgs args)
		{
			if (args.Length < 2)
			{
				args.Output.Error("Usage: jms-echo [info/detail/warning/error] [message]");
				return;
			}
			OutputLevel level = args.Args.GetEnum(0, OutputLevel.Info);
			args.Output.Write(level, args.Args.GetStringFrom(1));
		}

		private static void Nearby(ModCommandArgs args)
		{
			if (!args.HasCenter)
			{
				args.Output.Error("This needs a player position to measure from.");
				return;
			}
			float radius = args.ReadRadius(0, 32f, 256f);
			int num = Character.GetAllCharacters().Count((Character c) => (Object)(object)c != (Object)null && !c.IsPlayer() && Utils.DistanceXZ(((Component)c).transform.position, args.Center) <= radius);
			args.Output.Info($"{num} creatures within {radius}m.");
		}

		private static void WorldInfo(ModCommandArgs args)
		{
			args.Output.Info("World      : " + ZNet.instance.GetWorldName());
			args.Output.Detail("Seed       : " + ZNet.m_world?.m_seedName);
			args.Output.Detail($"Peers      : {ZNet.instance.GetPeers().Count}");
			args.Output.Detail($"ZDOs       : {((ZDOMan.instance != null) ? ZDOMan.instance.NrOfObjects() : 0)}");
			args.Output.Detail($"Zones      : {(((Object)(object)ZoneSystem.instance != (Object)null) ? ZoneSystem.instance.m_generatedZones.Count : 0)}");
			if (args.HasCenter)
			{
				args.Output.Detail($"You are at : {args.Center.x:0}, {args.Center.z:0}");
			}
		}

		private static void RegisterHelpCommand()
		{
			new ModCommand("jms-help", "Format: [optional: area] Lists this mod's console commands, optionally just one area.", Help, "meta", HelpOptions, false, false, false, false, null);
		}

		private static List<string> HelpOptions(string[] input)
		{
			if (input.Length > 2)
			{
				return new List<string>();
			}
			return (from area in (from command in Registry.Values
					where !command.HideFromHelp
					select command.Area).Distinct()
				orderby area
				select area).ToList();
		}

		private static void Help(ModCommandArgs args)
		{
			string filter = args.Args.GetString(0, null);
			if (filter != null && !HelpOptions(new string[2] { "", "" }).Contains(filter))
			{
				args.Output.Warning("Unknown area '" + filter + "'. Areas: " + string.Join(", ", HelpOptions(new string[2] { "", "" })));
				return;
			}
			args.Output.Info("ValheimCommunityPatchExtras commands:", log: false);
			foreach (IGrouping<string, ModCommand> item in from command in Registry.Values
				where !command.HideFromHelp
				where filter == null || command.Area == filter
				group command by command.Area into @group
				orderby @group.Key
				select @group)
			{
				args.Output.Info("  [" + item.Key + "]", log: false);
				foreach (ModCommand item2 in item.OrderBy((ModCommand command) => ((ConsoleCommand)command).Command))
				{
					args.Output.Detail("    " + ((ConsoleCommand)item2).Command + Tags(item2) + " - " + ((ConsoleCommand)item2).Description, log: false);
					string text = AliasesOf(item2);
					if (text.Length > 0)
					{
						args.Output.Detail("      also accepts: " + text, log: false);
					}
				}
			}
		}

		private static string Tags(ModCommand command)
		{
			List<string> list = new List<string>();
			if (((ConsoleCommand)command).IsCheat)
			{
				list.Add("cheat");
			}
			if (command.RequiresAdmin)
			{
				list.Add("admin");
			}
			if (command.ServerAuthoritative)
			{
				list.Add("server");
			}
			if (list.Count != 0)
			{
				return " (" + string.Join(", ", list) + ")";
			}
			return string.Empty;
		}

		private static string AliasesOf(ModCommand command)
		{
			return string.Join(", ", from other in Registry.Values
				where other.HideFromHelp && other.Canonical == ((ConsoleCommand)command).Command
				select ((ConsoleCommand)other).Command into name
				orderby name
				select name);
		}

		internal static void Init()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!initialized)
			{
				initialized = true;
				harmony = new Harmony("MidnightsFX.ValheimCommunityPatchExtras.terminal");
				PatchTabCompletion("tabCycle");
				PatchTabCompletion("updateSearch");
				TerminalNetwork.Init();
				RegisterCommands();
				Logger.LogDebug($"Registered {Registry.Count} console commands.");
			}
		}

		private static void PatchTabCompletion(string methodName)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(Terminal), methodName, (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Logger.LogWarning("Terminal." + methodName + " not found; per-argument tab completion is disabled.");
				}
				else
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(TerminalManager), "ContextOptionsPrefix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Could not patch Terminal." + methodName + " for tab completion: " + ex.Message);
			}
		}

		internal static void Register(ModCommand command)
		{
			Registry[Key(((ConsoleCommand)command).Command)] = command;
		}

		private static string Key(string name)
		{
			return (name ?? string.Empty).ToLowerInvariant();
		}

		private static ModCommand Lookup(string name)
		{
			if (!Registry.TryGetValue(Key(name), out var value))
			{
				return null;
			}
			return value;
		}

		internal static void Execute(string name, ConsoleEventArgs consoleArgs)
		{
			ModCommand modCommand = Lookup(name);
			if (modCommand == null)
			{
				return;
			}
			string[] args = consoleArgs.Args.Skip(1).ToArray();
			TerminalOutput terminalOutput = TerminalOutput.Local(consoleArgs.Context);
			if (!SynchronizationManager.Instance.PlayerIsAdmin)
			{
				terminalOutput.Error("Only server admins can run " + modCommand.Canonical + ".");
				return;
			}
			if (!modCommand.ServerAuthoritative)
			{
				Invoke(modCommand, args, terminalOutput);
				return;
			}
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				terminalOutput.Error("You must be in a world to use " + modCommand.Canonical + ".");
				return;
			}
			if (ZNet.instance.IsServer())
			{
				Invoke(modCommand, args, terminalOutput);
				return;
			}
			if (modCommand.RequiresAdmin && !SynchronizationManager.Instance.PlayerIsAdmin)
			{
				terminalOutput.Error("Only server admins can run " + modCommand.Canonical + " from a client.");
				return;
			}
			ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
			if (serverPeer == null)
			{
				terminalOutput.Error("No server connection, so " + modCommand.Canonical + " cannot be sent.");
				return;
			}
			responseTerminal = consoleArgs.Context;
			terminalOutput.Info("Asked the server to run " + modCommand.Canonical + "; its output follows.");
			TerminalNetwork.SendRequest(serverPeer.m_uid, modCommand.Canonical, args);
		}

		internal static void ExecuteFromNetwork(string name, string[] args, Vector3 center, bool hasCenter, TerminalOutput output)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			ModCommand modCommand = Lookup(name);
			if (modCommand == null || !modCommand.ServerAuthoritative)
			{
				output.Error("'" + name + "' is not a server-runnable command.");
				output.Flush();
			}
			else
			{
				Invoke(modCommand, args, center, hasCenter, output);
			}
		}

		private static void Invoke(ModCommand command, string[] args, TerminalOutput output)
		{
			//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_0029: 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)
			Vector3 center = Vector3.zero;
			bool hasCenter = false;
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				center = ((Component)Player.m_localPlayer).transform.position;
				hasCenter = true;
			}
			Invoke(command, args, center, hasCenter, output);
		}

		private static void Invoke(ModCommand command, string[] args, Vector3 center, bool hasCenter, TerminalOutput output)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				command.Action(new ModCommandArgs(args, center, hasCenter, output));
			}
			catch (Exception ex)
			{
				output.Error(command.Canonical + " failed: " + ex.Message);
				Logger.LogError($"{command.Canonical} threw: {ex}");
			}
			finally
			{
				output.Flush();
			}
		}

		internal static void PrintResponse(OutputLevel level, string line)
		{
			TerminalOutput.LogLine(level, line);
			Terminal val = (((Object)(object)responseTerminal != (Object)null) ? responseTerminal : null);
			if ((Object)(object)val == (Object)null && (Object)(object)Console.instance != (Object)null)
			{
				val = (Terminal)(object)Console.instance;
			}
			TerminalOutput.PrintTo(val, level, line);
		}

		private static void ContextOptionsPrefix(Terminal __instance, ref string word, ref List<string> options, bool usePrefix)
		{
			if (usePrefix || (Object)(object)__instance == (Object)null || (Object)(object)__instance.m_input == (Object)null)
			{
				return;
			}
			string[] array = (((TMP_InputField)__instance.m_input).text ?? string.Empty).Split(new char[1] { ' ' });
			if (array.Length < 2)
			{
				return;
			}
			ModCommand modCommand = Lookup((__instance.m_tabPrefix == '\0') ? array[0] : ((array[0].Length == 0) ? string.Empty : array[0].Substring(1)));
			if (modCommand != null)
			{
				List<string> tabOptions = modCommand.GetTabOptions(array);
				if (tabOptions != null && tabOptions.Count != 0)
				{
					options = tabOptions;
					word = array[^1];
				}
			}
		}
	}
	internal enum OutputLevel : byte
	{
		Info,
		Detail,
		Warning,
		Error
	}
	internal delegate List<string> OptionProvider(string[] input);
	internal delegate void CommandAction(ModCommandArgs args);
	internal class ModCommand : ConsoleCommand
	{
		internal readonly string Canonical;

		internal readonly string Area;

		internal readonly CommandAction Action;

		internal readonly OptionProvider Options;

		internal readonly bool HideFromHelp;

		internal readonly bool ServerAuthoritative;

		internal readonly bool RequiresAdmin;

		internal ModCommand(string command, string description, CommandAction action, string area = "general", OptionProvider options = null, bool isCheat = false, bool serverAuthoritative = false, bool requiresAdmin = false, bool hideFromHelp = false, string canonical = null, params string[] aliases)
			: base(command, description, (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				TerminalManager.Execute(command, args);
			}, isCheat, false, false, hideFromHelp, false, false, (ConsoleOptionsFetcher)null, false, false, false)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			ModCommand modCommand = this;
			Canonical = canonical ?? command;
			Area = (string.IsNullOrEmpty(area) ? "general" : area);
			Action = action;
			Options = options;
			HideFromHelp = hideFromHelp;
			ServerAuthoritative = serverAuthoritative;
			RequiresAdmin = requiresAdmin;
			base.m_tabOptionsFetcher = (ConsoleOptionsFetcher)(() => modCommand.GetTabOptions(CurrentInput()));
			base.m_alwaysRefreshTabOptions = true;
			TerminalManager.Register(this);
			for (int num = 0; num < aliases.Length; num++)
			{
				new ModCommand(aliases[num], description, action, area, options, isCheat, serverAuthoritative, requiresAdmin, true, Canonical);
			}
		}

		internal List<string> GetTabOptions(string[] input)
		{
			if (Options == null)
			{
				return new List<string>();
			}
			try
			{
				return Options(input) ?? new List<string>();
			}
			catch (Exception ex)
			{
				Logger.LogDebug("Tab options for " + base.Command + " failed: " + ex.Message);
				return new List<string>();
			}
		}

		private static string[] CurrentInput()
		{
			Terminal instance = (Terminal)(object)Console.instance;
			return ((((Object)(object)instance?.m_input == (Object)null) ? string.Empty : ((TMP_InputField)instance.m_input).text) ?? string.Empty).Split(new char[1] { ' ' });
		}
	}
	internal class ModCommandArgs
	{
		internal readonly string[] Args;

		internal readonly TerminalOutput Output;

		internal readonly Vector3 Center;

		internal readonly bool HasCenter;

		internal int Length => Args.Length;

		internal ModCommandArgs(string[] args, Vector3 center, bool hasCenter, TerminalOutput output)
		{
			//IL_0018: 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)
			Args = args ?? new string[0];
			Center = center;
			HasCenter = hasCenter;
			Output = output;
		}

		internal bool Has(string flag)
		{
			return Args.Any((string a) => string.Equals(a, flag, StringComparison.OrdinalIgnoreCase));
		}
	}
	internal static class TerminalArgs
	{
		private const float CacheSeconds = 60f;

		private static readonly List<string> creatureNames = new List<string>();

		private static float creatureNamesAt;

		internal static string GetString(this string[] args, int index, string fallback = "")
		{
			if (args == null || args.Length <= index)
			{
				return fallback;
			}
			return args[index];
		}

		internal static string GetStringFrom(this string[] args, int index, string fallback = "")
		{
			if (args == null || args.Length <= index)
			{
				return fallback;
			}
			return string.Join(" ", args.Skip(index));
		}

		internal static int GetInt(this string[] args, int index, int fallback = 0)
		{
			string text = args.GetString(index, null);
			if (text == null)
			{
				return fallback;
			}
			if (!int.TryParse(text, out var result))
			{
				return fallback;
			}
			return result;
		}

		internal static float GetFloat(this string[] args, int index, float fallback = 0f)
		{
			string text = args.GetString(index, null);
			if (text == null)
			{
				return fallback;
			}
			if (!float.TryParse(text, out var result))
			{
				return fallback;
			}
			return result;
		}

		internal static T GetEnum<T>(this string[] args, int index, T fallback) where T : struct, Enum
		{
			string text = args.GetString(index, null);
			if (text == null)
			{
				return fallback;
			}
			if (!Enum.TryParse<T>(text, ignoreCase: true, out var result))
			{
				return fallback;
			}
			return result;
		}

		internal static float ReadRadius(this ModCommandArgs args, int index, float fallback, float max)
		{
			string text = args.Args.GetString(index, null);
			if (text == null)
			{
				return fallback;
			}
			if (!float.TryParse(text, out var result))
			{
				args.Output.Warning($"Radius must be a number; using {fallback}.");
				return fallback;
			}
			return Mathf.Clamp(result, 0f, max);
		}

		internal static List<string> Names<T>() where T : struct, Enum
		{
			return Enum.GetNames(typeof(T)).ToList();
		}

		internal static List<string> RadiusPresets(string[] input)
		{
			return new List<string> { "8", "16", "32", "64", "128", "256" };
		}

		internal static List<string> CreatureNames(string[] input)
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return creatureNames;
			}
			if (creatureNames.Count == 0 || Time.realtimeSinceStartup - creatureNamesAt > 60f)
			{
				creatureNames.Clear();
				creatureNames.AddRange(from p in ZNetScene.instance.m_prefabs
					where (Object)(object)p != (Object)null && (Object)(object)p.GetComponent<Character>() != (Object)null
					select ((Object)p).name);
				creatureNamesAt = Time.realtimeSinceStartup;
			}
			return creatureNames;
		}
	}
	internal static class TerminalNetwork
	{
		private static CustomRPC commandRequestRPC;

		private static CustomRPC commandOutputRPC;

		internal static void Init()
		{
			//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_0027: Expected O, but got Unknown
			//IL_0027: Expected O, but got Unknown
			//IL_003d: 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_0053: Expected O, but got Unknown
			//IL_0053: Expected O, but got Unknown
			commandRequestRPC = NetworkManager.Instance.AddRPC("ValheimCommunityPatchExtras_CommandRequest", new CoroutineHandler(OnServerReceiveCommandRequest), new CoroutineHandler(NoOp));
			commandOutputRPC = NetworkManager.Instance.AddRPC("ValheimCommunityPatchExtras_CommandOutput", new CoroutineHandler(NoOp), new CoroutineHandler(OnClientReceiveCommandOutput));
		}

		private static IEnumerator NoOp(long sender, ZPackage package)
		{
			yield break;
		}

		internal static void SendRequest(long serverUid, string command, string[] args)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_005b: 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)
			ZPackage val = new ZPackage();
			val.Write(command);
			val.Write(args.Length);
			foreach (string text in args)
			{
				val.Write(text);
			}
			bool flag = (Object)(object)Player.m_localPlayer != (Object)null;
			val.Write(flag);
			val.Write(flag ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
			commandRequestRPC.SendPackage(serverUid, val);
		}

		internal static void SendOutput(long peerUid, ZPackage package)
		{
			commandOutputRPC.SendPackage(peerUid, package);
		}

		private static IEnumerator OnServerReceiveCommandRequest(long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				yield break;
			}
			string text = package.ReadString();
			if (RequiresAdmin(text) && !SenderIsAdmin(sender))
			{
				Logger.LogWarning($"Rejecting '{text}' from non-admin peer {sender}.");
				TerminalOutput terminalOutput = TerminalOutput.Remote(sender);
				terminalOutput.Error("Only server admins can run " + text + ".", log: false);
				terminalOutput.Flush();
				yield break;
			}
			int num = package.ReadInt();
			string[] array = new string[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = package.ReadString();
			}
			bool hasCenter = package.ReadBool();
			Vector3 center = package.ReadVector3();
			TerminalManager.ExecuteFromNetwork(text, array, center, hasCenter, TerminalOutput.Remote(sender));
			yield return null;
		}

		private static IEnumerator OnClientReceiveCommandOutput(long sender, ZPackage package)
		{
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				TerminalManager.PrintResponse((OutputLevel)package.ReadByte(), package.ReadString());
			}
			yield return null;
		}

		private static bool RequiresAdmin(string command)
		{
			if (TerminalManager.Registry.TryGetValue(command.ToLowerInvariant(), out var value))
			{
				return value.RequiresAdmin;
			}
			return true;
		}

		private static bool SenderIsAdmin(long sender)
		{
			ZNet instance = ZNet.instance;
			ZNetPeer val = ((instance != null) ? instance.GetPeer(sender) : null);
			if (val == null || val.m_socket == null)
			{
				return false;
			}
			return ZNet.instance.IsAdmin(val.m_socket.GetHostName());
		}
	}
	internal class TerminalOutput
	{
		private const string HexInfo = "#34D399";

		private const string HexDetail = "#60A5FA";

		private const string HexWarning = "#FBBF24";

		private const string HexError = "#F87171";

		private const int BatchLines = 25;

		private const float BatchSeconds = 0.5f;

		private readonly Terminal terminal;

		private readonly long peer;

		private readonly bool remote;

		private readonly List<KeyValuePair<OutputLevel, string>> pending;

		private float lastFlush;

		private TerminalOutput(Terminal context)
		{
			terminal = context;
			remote = false;
		}

		private TerminalOutput(long senderUid)
		{
			peer = senderUid;
			remote = true;
			pending = new List<KeyValuePair<OutputLevel, string>>();
			lastFlush = Time.realtimeSinceStartup;
		}

		internal static TerminalOutput Local(Terminal context)
		{
			return new TerminalOutput(context);
		}

		internal static TerminalOutput Remote(long senderUid)
		{
			return new TerminalOutput(senderUid);
		}

		internal void Info(string message, bool log = true)
		{
			Write(OutputLevel.Info, message, log);
		}

		internal void Detail(string message, bool log = true)
		{
			Write(OutputLevel.Detail, message, log);
		}

		internal void Warning(string message, bool log = true)
		{
			Write(OutputLevel.Warning, message, log);
		}

		internal void Error(string message, bool log = true)
		{
			Write(OutputLevel.Error, message, log);
		}

		internal void Write(OutputLevel level, string message, bool log = true)
		{
			if (!string.IsNullOrEmpty(message))
			{
				if (log)
				{
					LogLine(level, message);
				}
				string[] array = message.Split(new char[1] { '\n' });
				foreach (string text in array)
				{
					Deliver(level, text.TrimEnd(new char[1] { '\r' }));
				}
			}
		}

		private void Deliver(OutputLevel level, string line)
		{
			if (!remote)
			{
				Terminal obj = terminal;
				if (obj != null)
				{
					obj.AddString(Colorize(level, line));
				}
			}
			else
			{
				pending.Add(new KeyValuePair<OutputLevel, string>(level, line));
				if (pending.Count >= 25 || Time.realtimeSinceStartup - lastFlush >= 0.5f)
				{
					Flush();
				}
			}
		}

		internal void Flush()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			if (!remote || pending.Count == 0)
			{
				return;
			}
			lastFlush = Time.realtimeSinceStartup;
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZNet.instance.GetPeer(peer) == null)
			{
				pending.Clear();
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(pending.Count);
			foreach (KeyValuePair<OutputLevel, string> item in pending)
			{
				val.Write((byte)item.Key);
				val.Write(item.Value);
			}
			pending.Clear();
			TerminalNetwork.SendOutput(peer, val);
		}

		internal static void LogLine(OutputLevel level, string message)
		{
			switch (level)
			{
			case OutputLevel.Warning:
				Logger.LogWarning(message);
				break;
			case OutputLevel.Error:
				Logger.LogError(message);
				break;
			default:
				Logger.LogInfo(message);
				break;
			}
		}

		internal static void PrintTo(Terminal context, OutputLevel level, string line)
		{
			if (context != null)
			{
				context.AddString(Colorize(level, line));
			}
		}

		private static string Colorize(OutputLevel level, string line)
		{
			if (ValConfig.EnableTerminalColors == null || !ValConfig.EnableTerminalColors.Value)
			{
				return line;
			}
			return level switch
			{
				OutputLevel.Detail => "<color=#60A5FA>" + line + "</color>", 
				OutputLevel.Warning => "<color=#FBBF24>" + line + "</color>", 
				OutputLevel.Error => "<color=#F87171>" + line + "</color>", 
				_ => "<color=#34D399>" + line + "</color>", 
			};
		}
	}
	internal class ValConfig
	{
		public static ConfigFile cfg;

		public static ConfigEntry<bool> EnableDebugMode;

		public static ConfigEntry<bool> EnableTerminalColors;

		public static ConfigEntry<bool> ShowQuickConfigButton;

		public static ConfigEntry<int> InMemoryModificationsPerTick;

		public static ConfigEntry<float> ConfigApplyDelay;

		public static ConfigEntry<float> ConfigPollIntervalSeconds;

		public static readonly string cfgFolder = "ValheimCommunityPatchExtras";

		public ValConfig(ConfigFile cf)
		{
			cfg = cf;
			cfg.SaveOnConfigSet = true;
			CreateConfigValues(cf);
			Logger.SetDebugLogging(EnableDebugMode.Value);
			ConfigFileWatcher.Register(cfg.ConfigFilePath, OnMainConfigFileChanged);
		}

		private static void OnMainConfigFileChanged(string _)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				Logger.LogInfo("Configuration file has been changed, reloading settings.");
				cfg.Reload();
			}
		}

		public static void SaveOnSet(bool enabled)
		{
			cfg.SaveOnConfigSet = enabled;
			cfg.Save();
		}

		private void CreateConfigValues(ConfigFile Config)
		{
			//IL_001a: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			EnableDebugMode = Config.Bind<bool>("Client config", "EnableDebugMode", false, new ConfigDescription("Enables Debug logging.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} }));
			EnableDebugMode.SettingChanged += Logger.EnableDebugLogging;
			Logger.CheckEnableDebugLogging();
			EnableTerminalColors = Config.Bind<bool>("Client config", "EnableTerminalColors", true, new ConfigDescription("Colours this mod's console command output by severity.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes() }));
			ShowQuickConfigButton = Config.Bind<bool>("Client config", "ShowQuickConfigButton", true, new ConfigDescription("Show this mod in the shared in-game config launcher (bottom right of the main and pause menus).", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes() }));
			ShowQuickConfigButton.SettingChanged += delegate
			{
				ExampleConfigPanel.ApplyRegistration();
			};
			InMemoryModificationsPerTick = BindServerConfig("Config", "Updates Per Tick", 20, "Number of updates per tick that are applied when modifying items or pieces.", advanced: true, 1);
			ConfigApplyDelay = BindServerConfig("Config", "Config Apply Delay", 1f, "Delay in seconds before a changed config entry is applied in-game. Coalesces a burst of rapid edits (typing, file reloads, server sync) into a single apply. Set to 0 to apply instantly.", advanced: true, 0f, 10f);
			ConfigPollIntervalSeconds = BindServerConfig("Config", "Config Poll Interval", 30f, "Seconds between checks for edits to this mod's yaml config files and its BepInEx config file. Lower reacts faster to a hand edit, higher does less disk work.", advanced: true, 1f, 300f);
			ZoneLoadRadiusPatch.BindConfig();
			GrassDistancePatch.BindConfig();
			CutscenePatch.BindConfig();
		}

		public static ConfigEntry<float> BindClientConfig(string category, string key, float value, string description, bool advanced = false, float valMin = 0f, float valMax = 150f)
		{
			//IL_001a: 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_002d: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			return cfg.Bind<float>(category, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(valMin, valMax), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<int> BindClientConfig(string category, string key, int value, string description, bool advanced = false, int valMin = 0, int valMax = 150)
		{
			//IL_001a: 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_002d: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			return cfg.Bind<int>(category, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<int>(valMin, valMax), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<bool> BindClientConfig(string category, string key, bool value, string description, bool advanced = false)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			return cfg.Bind<bool>(category, key, value, new ConfigDescription(description, (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<float[]> BindServerConfig(string category, string key, float[] value, string description, bool advanced = false, float valMin = 0f, float valMax = 150f)
		{
			//IL_001a: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			return cfg.Bind<float[]>(category, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(valMin, valMax), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<bool> BindServerConfig(string category, string key, bool value, string description, AcceptableValueBase acceptableValues = null, bool advanced = false)
		{
			//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_002d: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			return cfg.Bind<bool>(category, key, value, new ConfigDescription(description, acceptableValues, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<int> BindServerConfig(string category, string key, int value, string description, bool advanced = false, int valMin = 0, int valMax = 150)
		{
			//IL_001a: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			return cfg.Bind<int>(category, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<int>(valMin, valMax), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<int> BindServerConfig(string category, string key, int value, string description, AcceptableValueBase acceptableValues, bool advanced = false)
		{
			//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_002d: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			return cfg.Bind<int>(category, key, value, new ConfigDescription(description, acceptableValues, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<float> BindServerConfig(string category, string key, float value, string description, bool advanced = false, float valMin = 0f, float valMax = 150f)
		{
			//IL_001a: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			return cfg.Bind<float>(category, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(valMin, valMax), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<float> BindServerConfig(string category, string key, float value, string description, AcceptableValueBase acceptableValues, bool advanced = false)
		{
			//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_002d: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			return cfg.Bind<float>(category, key, value, new ConfigDescription(description, acceptableValues, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<string> BindServerConfig(string category, string key, string value, string description, AcceptableValueList<string> acceptableValues = null, bool advanced = false)
		{
			//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_002d: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			return cfg.Bind<string>(category, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)acceptableValues, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}
	}
	[BepInPlugin("MidnightsFX.ValheimCommunityPatchExtras", "ValheimCommunityPatchExtras", "0.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	internal class CommunityPatchExtras : BaseUnityPlugin
	{
		public const string PluginGUID = "MidnightsFX.ValheimCommunityPatchExtras";

		public const string PluginName = "ValheimCommunityPatchExtras";

		public const string PluginVersion = "0.1.1";

		internal static ManualLogSource Log;

		internal ValConfig cfg;

		public static CustomLocalization Localization = LocalizationManager.Instance.GetLocalization();

		public static AssetBundle EmbeddedResourceBundle;

		private readonly Harmony harmony = new Harmony("MidnightsFX.ValheimCommunityPatchExtras");

		public void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			cfg = new ValConfig(((BaseUnityPlugin)this).Config);
			harmony.PatchAll(typeof(CommunityPatchExtras).Assembly);
			LocalizationLoader.AddLocalizations();
			TerminalManager.Init();
			YamlConfigManager.Init();
			ExampleConfigPanel.Init();
			ValConfig.SaveOnSet(enabled: true);
		}

		public void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}
	}
}
namespace CommunityPatchExtras.Patches
{
	[HarmonyPatch]
	internal static class CutscenePatch
	{
		internal static ConfigEntry<bool> PlayStartupCinematic;

		internal static ConfigEntry<bool> PlayCharacterIntro;

		internal static ConfigEntry<bool> PlayDreamCinematics;

		internal static ConfigEntry<bool> PlayEndingCinematic;

		private static bool _shippedOnStartup;

		private static bool _shippedOnNewWorld;

		private static bool _shippedCaptured;

		internal static void BindConfig()
		{
			PlayStartupCinematic = ValConfig.BindClientConfig("Cutscenes", "Play Startup Cinematic", value: true, "Whether the opening cinematic plays on the way to the main menu when you launch the game. Vanilla plays it once per launch and never again in that session; turning this off goes straight to the menu instead. Still watchable any time from the main menu's Cinematics list. Per-machine: this is a presentation setting and is not synced from the server.");
			PlayCharacterIntro = ValConfig.BindClientConfig("Cutscenes", "Play New Character Intro", value: true, "Whether the arrival sequence plays the first time a character spawns in a world - the raven's greeting and the valkyrie flight that drops you at the spawn stones. Turning this off puts you on the ground immediately, which is the same thing vanilla's own Skip button in the pause menu does. On a BRAND NEW world the intro also covers world generation, which runs at a much heavier per-frame budget once nothing is on screen to protect - so skipping it trades the flight for a stuttery first minute or two while the world finishes generating around you. Per-machine: not synced from the server, and inert on a dedicated server, which never plays one.");
			PlayDreamCinematics = ValConfig.BindClientConfig("Cutscenes", "Play Dream Cinematics", value: true, "Whether the dream videos play - the ones queued by killing a boss or by offering a trophy at a boss stone, which then run the next time you sleep. Turning this off gives you the ordinary random dream text instead, exactly as a night with no cinematic queued does. Skipping one costs you nothing: the main menu's Cinematics list unlocks these from the boss kill itself, not from having watched the dream. Per-machine: the queue is still sent to every player, and each machine decides for itself whether to play it, so this never skips anyone else's dream.");
			PlayEndingCinematic = ValConfig.BindClientConfig("Cutscenes", "Play Ending Cinematic", value: true, "Whether interacting with \"THE END\" plays the outro video and rolls the credits. Turning this off goes straight to the log out that ends that sequence anyway - a host with other players still connected stays in the world, just as in vanilla. Both the outro and the credits remain in the main menu's Cinematics list. Per-machine: this only affects what your own client plays.");
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CinematicsManager), "Awake")]
		private static void CinematicsManagerAwakePostfix(CinematicsManager __instance)
		{
			if (!_shippedCaptured)
			{
				_shippedCaptured = true;
				_shippedOnStartup = __instance.m_introOnStartup;
				_shippedOnNewWorld = __instance.m_introOnNewWorld;
			}
			bool flag = PlayStartupCinematic == null || PlayStartupCinematic.Value;
			bool flag2 = PlayCharacterIntro == null || PlayCharacterIntro.Value;
			__instance.m_introOnStartup = flag && _shippedOnStartup;
			__instance.m_introOnNewWorld = flag2 && _shippedOnNewWorld;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Game), "Start")]
		private static void GameStartPostfix(Game __instance)
		{
			if (PlayCharacterIntro != null && !PlayCharacterIntro.Value && __instance.m_queuedIntro)
			{
				__instance.m_queuedIntro = false;
				Logger.LogInfo("New character intro suppressed; spawning directly at the spawn point.");
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CinematicsManager), "OnSleep")]
		private static bool OnSleepPrefix()
		{
			if (PlayDreamCinematics == null || PlayDreamCinematics.Value)
			{
				return true;
			}
			if (string.IsNullOrEmpty(CinematicsManager.m_dreamCinematic))
			{
				return false;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null || !Player.m_localPlayer.IsSleeping())
			{
				return false;
			}
			Logger.LogInfo("Dream cinematic '" + CinematicsManager.m_dreamCinematic + "' skipped; it stays unlocked in the main menu's Cinematics list.");
			CinematicsManager.m_dreamCinematic = "";
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(EndCredits), "StartEndCredits")]
		private static bool StartEndCreditsPrefix(EndCredits __instance)
		{
			if (PlayEndingCinematic == null || PlayEndingCinematic.Value)
			{
				return true;
			}
			__instance.m_queueCredits = false;
			__instance.m_queueLogout = true;
			Logger.LogInfo("Ending cinematic skipped; logging out as the credits would have.");
			return false;
		}
	}
	[HarmonyPatch(typeof(ClutterSystem))]
	internal static class GrassDistancePatch
	{
		private struct ClutterLod
		{
			internal InstanceRenderer Renderer;

			internal float Min;

			internal float Max;
		}

		internal static ConfigEntry<float> Distance;

		internal static ConfigEntry<int> PatchesPerFrame;

		private static float _vanillaDistance;

		private static bool _vanillaCaptured;

		private static readonly List<ClutterLod> Lods = new List<ClutterLod>();

		private static bool _lodsCaptured;

		private static bool _lodsScaled;

		private static int _budget;

		internal static void BindConfig()
		{
			Distance = ValConfig.BindClientConfig("Grass", "Grass Distance", 40f, "How far from you, in metres, grass and other ground clutter is grown. 40 is exactly vanilla. Raising it is capped at whatever the loaded zones can actually cover - your Simulation Distance setting, so 128 m at its default of 2 - because clutter cannot be placed on terrain that is not loaded. Cost grows with the SQUARE of this number, and it is memory rather than framerate that bites first - each step up is roughly double the grass patches of the last, so raise it a little at a time and watch RAM. Lower it below 40 to buy back performance on a weak machine. Per-machine: this is a rendering setting and is not synced from the server.", advanced: false, 16f, 256f);
			PatchesPerFrame = ValConfig.BindClientConfig("Grass", "Grass Patches Per Frame", 8, "How many clutter patches may be built per frame while Grass Distance is raised above vanilla. Vanilla builds 1, which is fine over its 40 m but would leave a raised radius visibly growing in for tens of seconds. Higher fills faster after a world load or a graphics change at the cost of a heavier frame while it does. Ignored at or below the vanilla distance.", advanced: true, 1, 64);
			Distance.SettingChanged += delegate
			{
				ConfigChangeDebouncer.Schedule(typeof(GrassDistancePatch), Apply);
			};
		}

		private static float ResolveDistance()
		{
			//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)
			ZoneSystem instance = ZoneSystem.instance;
			if ((Object)(object)instance == (Object)null || Distance == null)
			{
				return _vanillaDistance;
			}
			float value = Distance.Value;
			if (value <= _vanillaDistance)
			{
				return value;
			}
			SimulationDistance simulationDistance = instance.m_simulationDistance;
			float num = (float)(((SimulationDistance)(ref simulationDistance)).NearSimulationDistance - ((!((SimulationDistance)(ref simulationDistance)).IsClassic) ? 1 : 0)) * instance.m_zoneSize;
			return Mathf.Max(_vanillaDistance, Mathf.Min(value, num));
		}

		private static void Apply()
		{
			Apply("setting changed");
		}

		private static void Apply(string reason)
		{
			ClutterSystem instance = ClutterSystem.instance;
			if (!((Object)(object)instance == (Object)null) && _vanillaCaptured)
			{
				float num = ResolveDistance();
				if (!Mathf.Approximately(instance.m_distance, num))
				{
					instance.m_distance = num;
					ApplyLodScale(num);
					instance.ClearAll();
					Logger.LogInfo($"Grass distance applied: {num:0.#} m (vanilla {_vanillaDistance:0.#}; {reason}).");
				}
			}
		}

		private static void CaptureLods(ClutterSystem clutter)
		{
			if (_lodsCaptured)
			{
				return;
			}
			_lodsCaptured = true;
			foreach (Clutter item in clutter.m_clutter)
			{
				if (item != null && item.m_instanced && !((Object)(object)item.m_prefab == (Object)null))
				{
					InstanceRenderer component = item.m_prefab.GetComponent<InstanceRenderer>();
					if (!((Object)(object)component == (Object)null))
					{
						Lods.Add(new ClutterLod
						{
							Renderer = component,
							Min = component.m_lodMinDistance,
							Max = component.m_lodMaxDistance
						});
					}
				}
			}
		}

		private static void ApplyLodScale(float distance)
		{
			float num = distance / _vanillaDistance;
			bool flag = num > 1f;
			if (!flag && !_lodsScaled)
			{
				return;
			}
			_lodsScaled = flag;
			foreach (ClutterLod lod in Lods)
			{
				if (!((Object)(object)lod.Renderer == (Object)null))
				{
					lod.Renderer.m_lodMinDistance = (flag ? (lod.Min * num) : lod.Min);
					lod.Renderer.m_lodMaxDistance = (flag ? (lod.Max * num) : lod.Max);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void AwakePostfix(ClutterSystem __instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)SystemInfo.graphicsDeviceType != 4)
			{
				_vanillaDistance = __instance.m_distance;
				_vanillaCaptured = true;
				CaptureLods(__instance);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("UpdateGrass")]
		private static void UpdateGrassPrefix(ClutterSystem __instance, ref bool rebuildAll)
		{
			if (_vanillaCaptured)
			{
				if (!Mathf.Approximately(__instance.m_distance, ResolveDistance()))
				{
					Apply("zone coverage");
				}
				if (__instance.m_distance > _vanillaDistance)
				{
					rebuildAll = false;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("GeneratePatches")]
		private static void GeneratePatchesPrefix(ClutterSystem __instance)
		{
			_budget = ((_vanillaCaptured && PatchesPerFrame != null && __instance.m_distance > _vanillaDistance) ? (PatchesPerFrame.Value - 1) : 0);
		}

		[HarmonyPrefix]
		[HarmonyPatch("GeneratePatch")]
		private static void GeneratePatchPrefix(ref bool generated)
		{
			if (generated && _budget > 0)
			{
				_budget--;
				generated = false;
			}
		}
	}
	[HarmonyPatch(typeof(ZNet))]
	internal static class ZoneLoadRadiusPatch
	{
		internal static ConfigEntry<int> ServerNearCap;

		internal static ConfigEntry<int> DistantArea;

		private static ZNet _confirmedFor;

		internal static void BindConfig()
		{
			ServerNearCap = ValConfig.BindServerConfig("Zone Loading", "Server Simulation Distance Cap", 2, "The highest Simulation Distance this server will grant a client, in zone rings of 64 m. 2 is exactly vanilla's default and changes nothing. Vanilla lets a player pick up to 6 in the graphics menu but caps them at whatever the server itself is set to, which on a dedicated server is 2 unless it was launched with -simulationdistance - so raising this is what lets players actually use the setting. It only raises the ceiling: each client still runs at its own chosen value, and a wider ring costs that client roughly (2n+1)^2 loaded objects and widens the ring where creatures and spawners actively simulate.", advanced: false, 2, 6);
			DistantArea = ValConfig.BindServerConfig("Zone Loading", "Distant Zone Load Radius", 4, "How many further zone rings of distant-flagged objects (lightweight landmark props) load beyond the simulated ring. Vanilla ships 2 at every Simulation Distance and offers no way to change it. These are cheap per zone, so the default is raised for better long-range silhouettes. Server's value wins for everyone; a client connected to a server without this mod stays at vanilla.", advanced: false, 2, 6);
			ServerNearCap.SettingChanged += delegate
			{
				ScheduleRenegotiate();
			};
			DistantArea.SettingChanged += delegate
			{
				ScheduleRenegotiate();
			};
			SynchronizationManager.OnConfigurationSynchronized += OnConfigurationSynchronized;
		}

		private static void ScheduleRenegotiate()
		{
			ConfigChangeDebouncer.Schedule(typeof(ZoneLoadRadiusPatch), Renegotiate);
		}

		private static void OnConfigurationSynchronized(object sender, ConfigurationSynchronizationEventArgs args)
		{
			if (args.UpdatedPluginGUIDs != null && args.UpdatedPluginGUIDs.Contains("MidnightsFX.ValheimCommunityPatchExtras"))
			{
				if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
				{
					_confirmedFor = ZNet.instance;
				}
				ScheduleRenegotiate();
			}
		}

		private static bool TrustedForSyncedValues(ZNet znet)
		{
			if (!znet.IsServer())
			{
				if ((Object)(object)_confirmedFor != (Object)null)
				{
					return _confirmedFor == znet;
				}
				return false;
			}
			return true;
		}

		private static void Renegotiate()
		{
			ZNet instance = ZNet.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.SimulationDistanceServerHandshake();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("GetDesiredSimulationDistance")]
		private static void GetDesiredSimulationDistancePostfix(ZNet __instance, ref SimulationDistance __result)
		{
			//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)
			int num = ((SimulationDistance)(ref __result)).NearSimulationDistance;
			int num2 = ((SimulationDistance)(ref __result)).FarSimulationDistance;
			bool flag = ((SimulationDistance)(ref __result)).IsClassic;
			if (ServerNearCap != null && ServerNearCap.Value > num && __instance.IsServer())
			{
				num = ServerNearCap.Value;
				flag = false;
			}
			if (DistantArea != null && DistantArea.Value > num2 && TrustedForSyncedValues(__instance))
			{
				num2 = DistantArea.Value;
			}
			if (num != ((SimulationDistance)(ref __result)).NearSimulationDistance || num2 != ((SimulationDistance)(ref __result)).FarSimulationDistance || flag != ((SimulationDistance)(ref __result)).IsClassic)
			{
				__result = new SimulationDistance(num, num2, flag);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("ApplySimulationDistance")]
		private static void ApplySimulationDistancePostfix(SimulationDistance simulationDistance)
		{
			Logger.LogInfo($"Simulation distance in effect: near {((SimulationDistance)(ref simulationDistance)).NearSimulationDistance}, " + $"far {((SimulationDistance)(ref simulationDistance)).FarSimulationDistance} " + "(" + (((SimulationDistance)(ref simulationDistance)).IsClassic ? "square" : "circular") + ").");
		}
	}
}
namespace CommunityPatchExtras.Common
{
	internal static class ConfigChangeDebouncer
	{
		private static readonly Dictionary<object, Action> pendingActions = new Dictionary<object, Action>();

		private static readonly Dictionary<object, float> fireAt = new Dictionary<object, float>();

		private static readonly HashSet<object> running = new HashSet<object>();

		internal static void Schedule(object key, Action action)
		{
			float num = ((ValConfig.ConfigApplyDelay != null) ? ValConfig.ConfigApplyDelay.Value : 0f);
			if (num <= 0f)
			{
				action();
				return;
			}
			ThreadingHelper instance = ThreadingHelper.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				pendingActions[key] = action;
				fireAt[key] = Time.realtimeSinceStartup + num;
				if (!running.Contains(key))
				{
					running.Add(key);
					((MonoBehaviour)instance).StartCoroutine(Run(key));
				}
			}
		}

		private static IEnumerator Run(object key)
		{
			float value;
			while (fireAt.TryGetValue(key, out value) && Time.realtimeSinceStartup < value)
			{
				yield return null;
			}
			pendingActions.TryGetValue(key, out var value2);
			pendingActions.Remove(key);
			fireAt.Remove(key);
			running.Remove(key);
			value2?.Invoke();
		}
	}
	internal static class ConfigDrawHelpers
	{
		private static readonly Dictionary<object, string> TextBuffer = new Dictionary<object, string>();

		private static readonly Dictionary<object, float> SliderPending = new Dictionary<object, float>();

		private static GUIStyle _headerButton;

		private static GUIStyle _groupLabel;

		private static GUIStyle _dim;

		internal static GUIStyle HeaderButton => _headerButton;

		internal static GUIStyle Dim => _dim;

		internal static void EnsureStyles()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//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_0045: Expected O, but got Unknown
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			if (_headerButton == null)
			{
				_headerButton = new GUIStyle(GUI.skin.button)
				{
					alignment = (TextAnchor)3,
					fontStyle = (FontStyle)1
				};
				_groupLabel = new GUIStyle(GUI.skin.label)
				{
					fontStyle = (FontStyle)1
				};
				_dim = new GUIStyle(GUI.skin.label)
				{
					fontStyle = (FontStyle)2,
					fontSize = 11
				};
			}
		}

		internal static ConfigurationManagerAttributes GetAttributes(ConfigEntryBase entry)
		{
			if (entry == null)
			{
				return null;
			}
			ConfigDescription description = entry.Description;
			if (description == null)
			{
				return null;
			}
			return description.Tags?.OfType<ConfigurationManagerAttributes>().FirstOrDefault();
		}

		internal static void Hide(ConfigEntryBase entry)
		{
			ConfigurationManagerAttributes attributes = GetAttributes(entry);
			if (attributes != null)
			{
				attributes.Browsable = false;
			}
		}

		internal static void GroupHeader(string text)
		{
			GUILayout.Space(4f);
			GUILayout.Label(text, _groupLabel, Array.Empty<GUILayoutOption>());
		}

		private static bool EnterPressed()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			if ((int)Event.current.type == 4)
			{
				if ((int)Event.current.keyCode != 13)
				{
					return (int)Event.current.keyCode == 271;
				}
				return true;
			}
			return false;
		}

		internal static void DrawBool(string label, ConfigEntry<bool> cfg)
		{
			bool flag = GUILayout.Toggle(cfg.Value, " " + label, Array.Empty<GUILayoutOption>());
			if (flag != cfg.Value)
			{
				cfg.Value = flag;
			}
		}

		internal static void DrawString(string label, ConfigEntry<string> cfg)
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(230f) });
			string text = "str_" + ((object)cfg).GetHashCode();
			GUI.SetNextControlName(text);
			bool flag = GUI.GetNameOfFocusedControl() == text;
			string value;
			string text2 = GUILayout.TextField((flag && TextBuffer.TryGetValue(cfg, out value)) ? value : cfg.Value, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(230f) });
			string value2;
			if (flag)
			{
				TextBuffer[cfg] = text2;
				if (EnterPressed() && cfg.Value != text2)
				{
					cfg.Value = text2;
				}
			}
			else if (TextBuffer.TryGetValue(cfg, out value2))
			{
				if (cfg.Value != value2)
				{
					cfg.Value = value2;
				}
				TextBuffer.Remove(cfg);
			}
			GUILayout.EndHorizontal();
		}

		internal static void DrawChoice(string label, ConfigEntry<string> cfg)
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(230f) });
			if (((ConfigEntryBase)cfg).Description.AcceptableValues is AcceptableValueList<string> val && val.AcceptableValues.Length != 0)
			{
				string[] acceptableValues = val.AcceptableValues;
				int num = Array.IndexOf(acceptableValues, cfg.Value);
				if (num < 0)
				{
					num = 0;
				}
				if (GUILayout.Button("◄", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(26f) }))
				{
					cfg.Value = acceptableValues[(num - 1 + acceptableValues.Length) % acceptableValues.Length];
				}
				GUILayout.Label(cfg.Value, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(160f) });
				if (GUILayout.Button("►", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(26f) }))
				{
					cfg.Value = acceptableValues[(num + 1) % acceptableValues.Length];
				}
			}
			else
			{
				GUILayout.Label(cfg.Value, Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndHorizontal();
		}

		internal static void DrawFloat(string label, ConfigEntry<float> cfg)
		{
			float num = 0f;
			float num2 = Mathf.Max(100f, cfg.Value);
			if (((ConfigEntryBase)cfg).Description.AcceptableValues is AcceptableValueRange<float> val)
			{
				num = val.MinValue;
				num2 = val.MaxValue;
			}
			float num3 = DrawSliderRow(label, cfg, cfg.Value, num, num2, isInt: false);
			if (num3 != cfg.Value)
			{
				cfg.Value = Mathf.Clamp(num3, num, num2);
			}
		}

		internal static void DrawInt(string label, ConfigEntry<int> cfg)
		{
			float num = 0f;
			float num2 = Mathf.Max(100f, (float)cfg.Value);
			if (((ConfigEntryBase)cfg).Description.AcceptableValues is AcceptableValueRange<int> val)
			{
				num = val.MinValue;
				num2 = val.MaxValue;
			}
			int num3 = Mathf.Clamp(Mathf.RoundToInt(DrawSliderRow(label, cfg, cfg.Value, num, num2, isInt: true)), (int)num, (int)num2);
			if (num3 != cfg.Value)
			{
				cfg.Value = num3;
			}
		}

		private static float DrawSliderRow(string label, object key, float current, float min, float max, bool isInt)
		{
			float num = current;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(230f) });
			float value;
			float num2 = (SliderPending.TryGetValue(key, out value) ? value : current);
			float num3 = GUILayout.HorizontalSlider(num2, min, max, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) });
			if (Mathf.Abs(num3 - num2) > Mathf.Epsilon)
			{
				SliderPending[key] = num3;
			}
			if (SliderPending.TryGetValue(key, out var value2))
			{
				num = value2;
				if (!Input.GetMouseButton(0))
				{
					SliderPending.Remove(key);
				}
			}
			string text = "num_" + key.GetHashCode();
			GUI.SetNextControlName(text);
			bool flag = GUI.GetNameOfFocusedControl() == text;
			string text2 = (isInt ? Mathf.RoundToInt(num).ToString() : num.ToString("0.###"));
			string value3;
			string text3 = GUILayout.TextField((flag && TextBuffer.TryGetValue(key, out value3)) ? value3 : text2, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
			string value4;
			if (flag)
			{
				TextBuffer[key] = text3;
				if (EnterPressed() && float.TryParse(text3, out var result))
				{
					num = result;
				}
			}
			else if (TextBuffer.TryGetValue(key, out value4))
			{
				if (float.TryParse(value4, out var result2))
				{
					num = result2;
				}
				TextBuffer.Remove(key);
			}
			GUILayout.Label("[" + (isInt ? min.ToString() : min.ToString("0.#")) + " - " + (isInt ? max.ToString() : max.ToString("0.#")) + "]", _dim, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) });
			GUILayout.EndHorizontal();
			return num;
		}
	}
	internal static class ItemConfigDrawer
	{
		private static readonly Dictionary<string, bool> Expanded = new Dictionary<string, bool>();

		private static readonly Dictionary<object, List<string[]>> RecipeRows = new Dictionary<object, List<string[]>>();

		private static int _order = 0;

		private static readonly (string name, ItemStat[] stats)[] StatGroups = new(string, ItemStat[])[4]
		{
			("Damage", new ItemStat[20]
			{
				ItemStat.slash,
				ItemStat.slash_per_level,
				ItemStat.blunt,
				ItemStat.blunt_per_level,
				ItemStat.pierce,
				ItemStat.pierce_per_level,
				ItemStat.fire,
				ItemStat.fire_per_level,
				ItemStat.lightning,
				ItemStat.lightning_per_level,
				ItemStat.frost,
				ItemStat.frost_per_level,
				ItemStat.poison,
				ItemStat.poison_per_level,
				ItemStat.spirit,
				ItemStat.spirit_per_level,
				ItemStat.pickaxe,
				ItemStat.pickaxe_per_level,
				ItemStat.chop,
				ItemStat.chop_per_level
			}),
			("Combat", new ItemStat[20]
			{
				ItemStat.attack_force,
				ItemStat.primary_attack_force_multiply,
				ItemStat.secondary_attack_force_multiply,
				ItemStat.primary_attack_stamina,
				ItemStat.primary_attack_eitr,
				ItemStat.primary_attack_flat_health_cost,
				ItemStat.primary_attack_percent_health_cost,
				ItemStat.primary_attack_health_returned,
				ItemStat.primary_attack_damage_bonus_per_missing_hp,
				ItemStat.primary_attack_projectile_count,
				ItemStat.secondary_attack_stamina,
				ItemStat.secondary_attack_eitr,
				ItemStat.secondary_attack_flat_health_cost,
				ItemStat.secondary_attack_percent_health_cost,
				ItemStat.projectile_velocity,
				ItemStat.projectile_accuracy_max,
				ItemStat.bow_draw_speed,
				ItemStat.crossbow_reload_speed,
				ItemStat.crossbow_reload_stamina_drain,
				ItemStat.draw_stamina_drain
			}),
			("Defense", new ItemStat[5]
			{
				ItemStat.block_armor,
				ItemStat.block_armor_per_level,
				ItemStat.parry,
				ItemStat.block_force,
				ItemStat.block_force_per_level
			}),
			("Item", new ItemStat[6]
			{
				ItemStat.durability,
				ItemStat.durability_per_level,
				ItemStat.max_item_level,
				ItemStat.tool_level,
				ItemStat.movement_speed,
				ItemStat.amount
			})
		};

		internal static void Attach(ItemDefinition itemdef)
		{
			ConfigDrawHelpers.Hide((ConfigEntryBase)(object)itemdef.StationLVLCfg);
			ConfigDrawHelpers.Hide((ConfigEntryBase)(object)itemdef.CraftAmountCfg);
			ConfigDrawHelpers.Hide((ConfigEntryBase)(object)itemdef.CraftedAtCfg);
			ConfigDrawHelpers.Hide((ConfigEntryBase)(object)itemdef.Recipe.RecipeConfig);
			if (itemdef.ModifableStats != null)
			{
				foreach (ItemStatConfig value in itemdef.ModifableStats.Values)
				{
					if (value.Cfg != null)
					{
						ConfigDrawHelpers.Hide((ConfigEntryBase)(object)value.Cfg);
					}
					if (value.CfgInt != null)
					{
						ConfigDrawHelpers.Hide((ConfigEntryBase)(object)value.CfgInt);
					}
				}
			}
			if (itemdef.DamageMods != null)
			{
				foreach (HitCustomDamageMod value2 in itemdef.DamageMods.Values)
				{
					if (value2.DmgModCfg != null)
					{
						ConfigDrawHelpers.Hide((ConfigEntryBase)(object)value2.DmgModCfg);
					}
				}
			}
			ConfigurationManagerAttributes attributes = ConfigDrawHelpers.GetAttributes((ConfigEntryBase)(object)itemdef.CraftableCfg);
			if (attributes != null)
			{
				attributes.CustomDrawer = delegate
				{
					Draw(itemdef);
				};
				attributes.HideSettingName = true;
				attributes.HideDefaultButton = true;
				attributes.Category = itemdef.Category.ToString();
				attributes.Order = _order--;
			}
		}

		private static void Draw(ItemDefinition itemdef)
		{
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			ConfigDrawHelpers.EnsureStyles();
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			bool value;
			bool flag = Expanded.TryGetValue(itemdef.DisplayName, out value) && value;
			if (GUILayout.Button((flag ? "▾ " : "▸ ") + itemdef.Name, ConfigDrawHelpers.HeaderButton, Array.Empty<GUILayoutOption>()))
			{
				flag = !flag;
				Expanded[itemdef.DisplayName] = flag;
			}
			if (flag)
			{
				int num;
				if (SynchronizationManager.Instance != null)
				{
					num = (SynchronizationManager.Instance.PlayerIsAdmin ? 1 : 0);
					if (num == 0)
					{
						GUILayout.Label("Server-controlled – admin only.", ConfigDrawHelpers.Dim, Array.Empty<GUILayoutOption>());
					}
				}
				else
				{
					num = 1;
				}
				bool enabled = GUI.enabled;
				GUI.enabled = (byte)num != 0;
				ConfigDrawHelpers.GroupHeader("Crafting");
				ConfigDrawHelpers.DrawBool("Craftable", itemdef.CraftableCfg);
				ConfigDrawHelpers.DrawString("Crafted at", itemdef.CraftedAtCfg);
				ConfigDrawHelpers.DrawInt("Station level", itemdef.StationLVLCfg);
				ConfigDrawHelpers.DrawInt("Craft amount", itemdef.CraftAmountCfg);
				DrawRecipeEditor(itemdef);
				HashSet<ItemStat> drawn = new HashSet<ItemStat>();
				(string, ItemStat[])[] statGroups = StatGroups;
				for (int i = 0; i < statGroups.Length; i++)
				{
					(string, ItemStat[]) tuple = statGroups[i];
					List<ItemStat> list = tuple.Item2.Where((ItemStat s) => IsConfigurable(itemdef, s)).ToList();
					bool flag2 = tuple.Item1 == "Damage" && itemdef.DamageMods != null && itemdef.DamageMods.Count > 0;
					if (list.Count == 0 && !flag2)
					{
						continue;
					}
					ConfigDrawHelpers.GroupHeader(tuple.Item1);
					foreach (ItemStat item in list)
					{
						DrawStat(itemdef, item);
						drawn.Add(item);
					}
					if (!flag2)
					{
						continue;
					}
					foreach (KeyValuePair<DamageType, HitCustomDamageMod> damageMod in itemdef.DamageMods)
					{
						if (damageMod.Value.Configurable && damageMod.Value.DmgModCfg != null)
						{
							ConfigDrawHelpers.DrawChoice(((object)damageMod.Key/*cast due to .constrained prefix*/).ToString() + " resistance", damageMod.Value.DmgModCfg);
						}
					}
				}
				if (itemdef.ModifableStats != null)
				{
					List<ItemStat> list2 = itemdef.ModifableStats.Keys.Where((ItemStat s) => !drawn.Contains(s) && IsConfigurable(itemdef, s)).ToList();
					if (list2.Count > 0)
					{
						ConfigDrawHelpers.GroupHeader("Other");
						foreach (ItemStat item2 in list2)
						{
							DrawStat(itemdef, item2);
						}
					}
				}
				GUI.enabled = enabled;
			}
			GUILayout.EndVertical();
		}

		private static bool IsConfigurable(ItemDefinition itemdef, ItemStat s)
		{
			if (itemdef.ModifableStats != null && itemdef.ModifableStats.TryGetValue(s, out var value))
			{
				return value.Configurable;
			}
			return false;
		}

		private static void DrawStat(ItemDefinition itemdef, ItemStat s)
		{
			ItemStatConfig itemStatConfig = itemdef.ModifableStats[s];
			string label = s.ToString().Replace('_', ' ');
			if (itemStatConfig.IsInt)
			{
				ConfigDrawHelpers.DrawInt(label, itemStatConfig.CfgInt);
			}
			else
			{
				ConfigDrawHelpers.DrawFloat(label, itemStatConfig.Cfg);
			}
		}

		private static void DrawRecipeEditor(ItemDefinition itemdef)
		{
			ConfigEntry<string> recipeConfig = itemdef.Recipe.RecipeConfig;
			ConfigDrawHelpers.GroupHeader("Recipe");
			if (!RecipeRows.TryGetValue(recipeConfig, out var value))
			{
				value = ParseCsv(recipeConfig.Value, 3);
				RecipeRows[recipeConfig] = value;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Resource (prefab)", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(200f) });
			GUILayout.Label("Amount", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) });
			GUILayout.Label("Per level", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
			GUILayout.EndHorizontal();
			for (int i = 0; i < value.Count; i++)
			{
				string[] array = value[i];
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				array[0] = GUILayout.TextField(array[0] ?? "", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(200f) });
				array[1] = DigitsOnly(GUILayout.TextField(array[1] ?? "", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) }));
				array[2] = DigitsOnly(GUILayout.TextField(array[2] ?? "", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) }));
				bool num = GUILayout.Button("✕", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(26f) });
				GUILayout.EndHorizontal();
				if (num)
				{
					value.RemoveAt(i);
					i--;
				}
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Add resource", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
			{
				value.Add(new string[3] { "", "1", "0" });
			}
			if (GUILayout.Button("Apply", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }))
			{
				recipeConfig.Value = SerializeCsv(value);
			}
			if (GUILayout.Button("Reload", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }))
			{
				RecipeRows[recipeConfig] = ParseCsv(recipeConfig.Value, 3);
			}
			GUILayout.EndHorizontal();
			GUILayout.Label("Applied: " + recipeConfig.Value, ConfigDrawHelpers.Dim, Array.Empty<GUILayoutOption>());
		}

		internal static List<string[]> ParseCsv(string csv, int cols)
		{
			List<string[]> list = new List<string[]>();
			string[] array = (csv ?? "").Split(new char[1] { '|' });
			foreach (string text in array)
			{
				if (!string.IsNullOrWhiteSpace(text))
				{
					string[] array2 = text.Split(new char[1] { ',' });
					string[] array3 = new string[cols];
					for (int j = 0; j < cols; j++)
					{
						array3[j] = ((j < array2.Length) ? array2[j] : "");
					}
					list.Add(array3);
				}
			}
			return list;
		}

		internal static string SerializeCsv(List<string[]> rows)
		{
			return string.Join("|", from r in rows
				where !string.IsNullOrWhiteSpace(r[0])
				select string.Join(",", r));
		}

		internal static string DigitsOnly(string s)
		{
			return new string((s ?? "").Where((char ch) => char.IsDigit(ch) || ch == '-').ToArray());
		}
	}
	internal static class PieceConfigDrawer
	{
		private static readonly Dictionary<string, bool> Expanded = new Dictionary<string, bool>();

		private static readonly Dictionary<object, List<string[]>> CostRows = new Dictionary<object, List<string[]>>();

		private static int _order = 0;

		internal static void Attach(JotunnPiece.JotunnBuildPiece jp)
		{
			ConfigDrawHelpers.Hide((ConfigEntryBase)(object)jp.Cfgs.Workbench);
			ConfigDrawHelpers.Hide((ConfigEntryBase)(object)jp.Cfgs.PieceCategory);
			ConfigDrawHelpers.Hide((ConfigEntryBase)(object)jp.Cfgs.PieceCost);
			ConfigurationManagerAttributes attributes = ConfigDrawHelpers.GetAttributes((ConfigEntryBase)(object)jp.Cfgs.Enabled);
			if (attributes != null)
			{
				attributes.CustomDrawer = delegate
				{
					Draw(jp);
				};
				attributes.HideSettingName = true;
				attributes.HideDefaultButton = true;
				attributes.Category = "Building Pieces";
				attributes.Order = _order--;
			}
		}

		private static void Draw(JotunnPiece.JotunnBuildPiece jp)
		{
			ConfigDrawHelpers.EnsureStyles();
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			bool value;
			bool flag = Expanded.TryGetValue(jp.Name, out value) && value;
			if (GUILayout.Button((flag ? "▾ " : "▸ ") + jp.Name, ConfigDrawHelpers.HeaderButton, Array.Empty<GUILayoutOption>()))
			{
				flag = !flag;
				Expanded[jp.Name] = flag;
			}
			if (flag)
			{
				int num;
				if (SynchronizationManager.Instance != null)
				{
					num = (SynchronizationManager.Instance.PlayerIsAdmin ? 1 : 0);
					if (num == 0)
					{
						GUILayout.Label("Server-controlled – admin only.", ConfigDrawHelpers.Dim, Array.Empty<GUILayoutOption>());
					}
				}
				else
				{
					num = 1;
				}
				bool enabled = GUI.enabled;
				GUI.enabled = (byte)num != 0;
				ConfigDrawHelpers.GroupHeader("Settings");
				ConfigDrawHelpers.DrawBool("Enabled", jp.Cfgs.Enabled);
				ConfigDrawHelpers.DrawString("Workbench", jp.Cfgs.Workbench);
				ConfigDrawHelpers.DrawChoice("Piece category", jp.Cfgs.PieceCategory);
				DrawCostEditor(jp);
				GUI.enabled = enabled;
			}
			GUILayout.EndVertical();
		}

		private static void DrawCostEditor(JotunnPiece.JotunnBuildPiece jp)
		{
			ConfigEntry<string> pieceCost = jp.Cfgs.PieceCost;
			ConfigDrawHelpers.GroupHeader("Building Cost");
			if (!CostRows.TryGetValue(pieceCost, out var value))
			{
				value = ItemConfigDrawer.ParseCsv(pieceCost.Value, 3);
				CostRows[pieceCost] = value;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Resource (prefab)", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(200f) });
			GUILayout.Label("Amount", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) });
			GUILayout.Label("Refund", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) });
			GUILayout.EndHorizontal();
			for (int i = 0; i < value.Count; i++)
			{
				string[] array = value[i];
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				array[0] = GUILayout.TextField(array[0] ?? "", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(200f) });
				array[1] = ItemConfigDrawer.DigitsOnly(GUILayout.TextField(array[1] ?? "", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) }));
				bool num = (array[2] ?? "").Trim().ToLower() != "false";
				bool flag = GUILayout.Toggle(num, num ? " refundable" : " no refund", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) });
				array[2] = (flag ? "true" : "false");
				bool num2 = GUILayout.Button("✕", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(26f) });
				GUILayout.EndHorizontal();
				if (num2)
				{
					value.RemoveAt(i);
					i--;
				}
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Add resource", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
			{
				value.Add(new string[3] { "", "1", "true" });
			}
			if (GUILayout.Button("Apply", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }))
			{
				pieceCost.Value = ItemConfigDrawer.SerializeCsv(value);
			}
			if (GUILayout.Button("Reload", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) }))
			{
				CostRows[pieceCost] = ItemConfigDrawer.ParseCsv(pieceCost.Value, 3);
			}
			GUILayout.EndHorizontal();
			GUILayout.Label("Applied: " + pieceCost.Value, ConfigDrawHelpers.Dim, Array.Empty<GUILayoutOption>());
		}
	}
	internal class JotunBatchLoader
	{
		internal static List<ItemDefinition> resourceDefinitions = new List<ItemDefinition>();

		internal static bool runningQueuedChanges = false;

		internal static AssetBundle Assets;

		internal static Dictionary<string, string> AddedItems = new Dictionary<string, string>();

		internal static List<string> ArcheryAmmoToAdd = new List<string>();

		private static readonly List<KeyValuePair<string, Action<ItemData>>> pendingWorldUpdates = new List<KeyValuePair<string, Action<ItemData>>>();

		private static bool worldUpdateScheduled = false;

		private static Dictionary<string, int> recipeIndexCache = null;

		internal static readonly AcceptableValueList<string> allowedModifiers = new AcceptableValueList<string>(new string[7]
		{
			((object)(DamageModifier)0/*cast due to .constrained prefix*/).ToString(),
			((object)(DamageModifier)6/*cast due to .constrained prefix*/).ToString(),
			((object)(DamageModifier)2/*cast due to .constrained prefix*/).ToString(),
			((object)(DamageModifier)6/*cast due to .constrained prefix*/).ToString(),
			((object)(DamageModifier)1/*cast due to .constrained prefix*/).ToString(),
			((object)(DamageModifier)5/*cast due to .constrained prefix*/).ToString(),
			((object)(DamageModifier)3/*cast due to .constrained prefix*/).ToString()
		});

		public bool BatchSetup(AssetBundle assetBundle, bool reverse_order = true)
		{
			Assets = assetBundle;
			if (reverse_order)
			{
				resourceDefinitions.Reverse();
			}
			WireConfigDefs();
			bool flag = false;
			if ((Object)(object)ZNet.instance != (Object)null && ZNetExtension.IsServerInstance(ZNet.instance))
			{
				flag = true;
			}
			if (!flag)
			{
				BatchAddItems();
				SetupOnChange();
				ItemManager.OnItemsRegistered += AddAmmoItemsToArcheryTarget;
				ItemManager.OnItemsRegistered += ReapplyAllRecipeConfig;
				SynchronizationManager.OnConfigurationSynchronized += OnModConfigsChanged;
			}
			ValConfig.cfg.Save();
			ValConfig.SaveOnSet(enabled: true);
			return true;
		}

		public bool AddDefinition(ItemDefinition itemdef)
		{
			resourceDefinitions.Add(itemdef);
			return true;
		}

		private static bool WireConfigDefs()
		{
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			foreach (ItemDefinition resourceDefinition in resourceDefinitions)
			{
				resourceDefinition.DisplayName = string.Join("", resourceDefinition.Name.Split((string[]?)null, StringSplitOptions.RemoveEmptyEntries));
				AddedItems.Add(resourceDefinition.DisplayName, resourceDefinition.Prefab);
				resourceDefinition.CraftableCfg = ValConfig.BindServerConfig($"{resourceDefinition.Category} - {resourceDefinition.Name}", resourceDefinition.DisplayName + "-craftable", resourceDefinition.Craftable, "Enable/Disable the crafting recipe for " + resourceDefinition.Name + ".");
				resourceDefinition.StationLVLCfg = ValConfig.BindServerConfig($"{resourceDefinition.Category} - {resourceDefinition.Name}", resourceDefinition.DisplayName + "-stationRequiredLevel", resourceDefinition.ReqStationlevel, "Sets the required minimum crafting station level to craft " + resourceDefinition.Name, advanced: true, 1, 4);
				resourceDefinition.CraftAmountCfg = ValConfig.BindServerConfig($"{resourceDefinition.Category} - {resourceDefinition.Name}", resourceDefinition.DisplayName + "-craftAmount", resourceDefinition.CraftAmount, "Sets the amount of " + resourceDefinition.Name + " crafted per recipe.", advanced: true, 1, 50);
				resourceDefinition.CraftedAtCfg = ValConfig.BindServerConfig($"{resourceDefinition.Category} - {resourceDefinition.Name}", resourceDefinition.DisplayName + "-craftedAt", resourceDefinition.CraftedAt, "Sets the crafting station for " + resourceDefinition.Name + ".");
				foreach (KeyValuePair<ItemStat, ItemStatConfig> modifableStat in resourceDefinition.ModifableStats)
				{
					if (modifableStat.Value.Configurable)
					{
						if (modifableStat.Value.IsInt)
						{
							modifableStat.Value.CfgInt = ValConfig.BindServerConfig($"{resourceDefinition.Category} - {resourceDefinition.Name}", $"{resourceDefinition.DisplayName}-{modifableStat.Key}", (int)modifableStat.Value.Default_value, $"Value for {modifableStat.Key} on {resourceDefinition.Name}", advanced: true, (int)modifableStat.Value.Min, (int)modifableStat.Value.Max);
						}
						else
						{
							modifableStat.Value.Cfg = ValConfig.BindServerConfig($"{resourceDefinition.Category} - {resourceDefinition.Name}", $"{resourceDefinition.DisplayName}-{modifableStat.Key}", modifableStat.Value.Default_value, $"Value for {modifableStat.Key} on {resourceDefinition.Name}", advanced: true, modifableStat.Value.Min, modifableStat.Value.Max);
						}
					}
				}
				if (resourceDefinition.DamageMods != null)
				{
					foreach (KeyValuePair<DamageType, HitCustomDamageMod> damageMod in resourceDefinition.DamageMods)
					{
						damageMod.Value.DmgModCfg = ValConfig.BindServerConfig($"{resourceDefinition.Category} - {resourceDefinition.Name}", $"{resourceDefinition.DisplayName}-{damageMod.Key}-DamageModifier", ((object)damageMod.Value.DamageModifier/*cast due to .constrained prefix*/).ToString(), $"Damage modifier for {damageMod.Key} on {resourceDefinition.Name}", allowedModifiers, advanced: true);
					}
				}
				resourceDefinition.Recipe.RecipeConfig = ValConfig.BindServerConfig($"{resourceDefinition.Category} - {resourceDefinition.Name}", resourceDefinition.DisplayName + "-recipe", BuildStringRecipeFromItemDef(resourceDefinition), "Recipe for " + resourceDefinition.Name + ". Should be in the format of Prefab,Amount,AmountPerLevel|Prefab,Amount,AmountPerLevel eg: Wood,12,2|Stone,2,0");
				if (!ValidateRecipeConfig(resourceDefinition))
				{
					BuildRecipeReqsFromDefault(resourceDefinition);
				}
				ItemConfigDrawer.Attach(resourceDefinition);
			}
			return true;
		}

		private bool SetupOnChange()
		{
			foreach (ItemDefinition resourceDefinition in resourceDefinitions)
			{
				ItemDefinition itemdef = resourceDefinition;
				itemdef.CraftableCfg.SettingChanged += delegate
				{
					ConfigChangeDebouncer.Schedule(itemdef.CraftableCfg, delegate
					{
						EnableDisableItemInDB(itemdef, itemdef.CraftableCfg.Value);
					});
				};
				itemdef.StationLVLCfg.SettingChanged += delegate
				{
					ConfigChangeDebouncer.Schedule(itemdef.StationLVLCfg, delegate
					{
						ModifyItemRecipeLevel(itemdef, itemdef.StationLVLCfg.Value);
					});
				};
				itemdef.CraftedAtCfg.SettingChanged += delegate
				{
					ConfigChangeDebouncer.Schedule(itemdef.CraftedAtCfg, delegate
					{
						ModifyItemRecipeCraftedAt(itemdef);
					});
				};
				itemdef.CraftAmountCfg.SettingChanged += delegate
				{
					ConfigChangeDebouncer.Schedule(itemdef.CraftAmountCfg, delegate
					{
						ModifyItemRecipeCraftAmount(itemdef, itemdef.CraftAmountCfg.Value);
					});
				};
				foreach (KeyValuePair<ItemStat, ItemStatConfig> modifableStat in itemdef.ModifableStats)
				{
					KeyValuePair<ItemStat, ItemStatConfig> stat = modifableStat;
					object statKey;
					if (stat.Value.Configurable)
					{
						statKey = (stat.Value.IsInt ? ((object)stat.Value.CfgInt) : ((object)stat.Value.Cfg));
						if (stat.Value.IsInt)
						{
							stat.Value.CfgInt.SettingChanged += UpdateFromConfig;
						}
						else
						{
							stat.Value.Cfg.SettingChanged += UpdateFromConfig;
						}
					}
					void UpdateFromConfig(object sender, EventArgs args)
					{
						ConfigChangeDebouncer.Schedule(statKey, delegate
						{
							if (((Behaviour)ZNet.instance).enabled)
							{
								if (stat.Value.IsInt)
								{
									stat.Value.Default_value = stat.Value.CfgInt.Value;
								}
								else
								{
									stat.Value.Default_value = stat.Value.Cfg.Value;
								}
								UpdateItemInPlayerInventory(itemdef.Prefab, delegate(ItemData item)
								{
									ItemDataConfigModifier(stat.Key, stat.Value.Default_value, item);
								});
								EnqueueWorldUpdate(itemdef.Prefab, delegate(ItemData item)
								{
									ItemDataConfigModifier(stat.Key, stat.Value.Default_value, item);
								});
							}
						});
					}
				}
				itemdef.Recipe.RecipeConfig.SettingChanged += delegate
				{
					ConfigChangeDebouncer.Schedule(itemdef.Recipe.RecipeConfig, delegate
					{
						if (ValidateRecipeConfig(itemdef))
						{
							ModifyItemRecipeInODB(itemdef);
						}
					});
				};
				if (itemdef.DamageMods == null)
				{
					continue;
				}
				foreach (KeyValuePair<DamageType, HitCustomDamageMod> dmgmod in itemdef.DamageMods)
				{
					dmgmod.Value.DmgModCfg.SettingChanged += delegate
					{
						ConfigChangeDebouncer.Schedule(dmgmod.Value.DmgModCfg, delegate
						{
							//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)
							if (((Behaviour)ZNet.instance).enabled)
							{
								DamageModifier modifier = (DamageModifier)Enum.Parse(typeof(DamageModifier), dmgmod.Value.DmgModCfg.Value);
								UpdateItemInPlayerInventory(itemdef.Prefab, delegate(ItemData item)
								{
									//IL_0001: 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)
									SetItemDamageModifier(modifier, dmgmod.Key, item);
								});
								EnqueueWorldUpdate(itemdef.Prefab, delegate(ItemData item)
								{
									//IL_0001: 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)
									SetItemDamageModifier(modifier, dmgmod.Key, item);
								});
							}
						});
					};
				}
			}
			return true;
		}

		private static void ReapplyAllRecipeConfig()
		{
			if ((Object)(object)ObjectDB.instance == (Object)null || ObjectDB.instance.m_recipes == null)
			{
				return;
			}
			foreach (ItemDefinition resourceDefinition in resourceDefinitions)
			{
				EnsureRecipeInDB(resourceDefinition);
				if (ValidateRecipeConfig(resourceDefinition))
				{
					ModifyItemRecipeInODB(resourceDefinition);
				}
				ModifyItemRecipeLevel(resourceDefinition, resourceDefinition.StationLVLCfg.Value);
				ModifyItemRecipeCraftedAt(resourceDefinition);
				ModifyItemRecipeCraftAmount(resourceDefinition, resourceDefinition.CraftAmountCfg.Value);
				EnableDisableItemInDB(resourceDefinition, resourceDefinition.CraftableCfg.Value);
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				Player.m_localPlayer.UpdateKnownRecipesList();
			}
		}

		private static void OnModConfigsChanged(object sender, ConfigurationSynchronizationEventArgs e)
		{
			if (e.UpdatedPluginGUIDs == null || e.UpdatedPluginGUIDs.Count <= 0 || e.UpdatedPluginGUIDs.Contains("MidnightsFX.ValheimCommunityPatchExtras"))
			{
				ReapplyAllRecipeConfig();
			}
		}

		private static bool BatchAddItems()
		{
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Expected O, but got Unknown
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			foreach (ItemDefinition resourceDefinition in resourceDefinitions)
			{
				GameObject val = Assets.LoadAsset<GameObject>($"Assets/Custom/Weapons/{resourceDefinition.Category}/{resourceDefinition.Prefab}.prefab");
				Sprite val2 = Assets.LoadAsset<Sprite>("Assets/Custom/Icons/" + resourceDefinition.Icon + ".png");
				ItemDrop component = val.GetComponent<ItemDrop>();
				foreach (KeyValuePair<ItemStat, ItemStatConfig> modifableStat in resourceDefinition.ModifableStats)
				{
					if (!modifableStat.Value.Configurable)
					{
						ItemDataConfigModifier(modifableStat.Key, modifableStat.Value.Default_value, component.m_itemData);
					}
					else if (modifableStat.Value.IsInt)
					{
						ItemDataConfigModifier(modifableStat.Key, modifableStat.Value.CfgInt.Value, component.m_itemData);
					}
					else
					{
						ItemDataConfigModifier(modifableStat.Key, modifableStat.Value.Cfg.Value, component.m_itemData);
					}
				}
				if (resourceDefinition.DamageMods != null)
				{
					foreach (KeyValuePair<DamageType, HitCustomDamageMod> damageMod in resourceDefinition.DamageMods)
					{
						if (damageMod.Value.Configurable && damageMod.Value.DmgModCfg != null)
						{
							SetItemDamageModifier((DamageModifier)Enum.Parse(typeof(DamageModifier), damageMod.Value.DmgModCfg.Value), damageMod.Key, component.m_itemData);
						}
					}
				}
				ItemConfig val3 = new ItemConfig();
				val3.Amount = resourceDefinition.CraftAmountCfg.Value;
				val3.CraftingStation = resourceDefinition.CraftedAtCfg.Value ?? "";
				val3.MinStationLevel = resourceDefinition.StationLVLCfg.Value;
				val3.Enabled = true;
				val3.Icons = (Sprite[])(object)new Sprite[1] { val2 };
				val3.Requirements = resourceDefinition.Recipe.RecipeReqs.ToArray();
				ItemConfig val4 = val3;
				ItemManager.Instance.AddItem(new CustomItem(val, true, val4));
				if (resourceDefinition.Category == ItemCategory.Arrows)
				{
					ArcheryAmmoToAdd.Add(resourceDefinition.Prefab);
				}
			}
			return true;
		}

		private static void ItemDataConfigModifier(ItemStat target_attribute, float updatedValue, ItemData itemData)
		{
			if (itemData != null)
			{
				switch (target_attribute)
				{
				case ItemStat.slash:
					itemData.m_shared.m_damages.m_slash = updatedValue;
					break;
				case ItemStat.slash_per_level:
					itemData.m_shared.m_damagesPerLevel.m_slash = updatedValue;
					break;
				case ItemStat.blunt:
					itemData.m_shared.m_damages.m_blunt = updatedValue;
					break;
				case ItemStat.blunt_per_level:
					itemData.m_shared.m_damagesPerLevel.m_blunt = updatedValue;
					break;
				case ItemStat.pierce:
					itemData.m_shared.m_damages.m_pierce = updatedValue;
					break;
				case ItemStat.pierce_per_level:
					itemData.m_shared.m_damagesPerLevel.m_pierce = updatedValue;
					break;
				case ItemStat.pickaxe:
					itemData.m_shared.m_damages.m_pickaxe = updatedValue;
					break;
				case ItemStat.pickaxe_per_level:
					itemData.m_shared.m_damagesPerLevel.m_pickaxe = updatedValue;
					break;
				case ItemStat.chop:
					itemData.m_shared.m_damages.m_chop = updatedValue;
					break;
				case ItemStat.chop_per_level:
					itemData.m_shared.m_damagesPerLevel.m_chop = updatedValue;
					break;
				case ItemStat.attack_force:
					itemData.m_shared.m_attackForce = updatedValue;
					break;
				case ItemStat.secondary_attack_force_multiply:
					itemData.m_shared.m_secondaryAttack.m_forceMultiplier = updatedValue;
					break;
				case ItemStat.primary_attack_force_multiply:
					itemData.m_shared.m_attack.m_forceMultiplier = updatedValue;
					break;
				case ItemStat.fire:
					itemData.m_shared.m_damages.m_fire = updatedValue;
					break;
				case ItemStat.fire_per_level:
					itemData.m_shared.m_damagesPerLevel.m_fire = updatedValue;
					break;
				case ItemStat.lightning:
					itemData.m_shared.m_damages.m_lightning = updatedValue;
					break;
				case ItemStat.lightning_per_level:
					itemData.m_shared.m_damagesPerLevel.m_lightning = updatedValue;
					break;
				case ItemStat.frost:
					itemData.m_shared.m_damages.m_frost = updatedValue;
					break;
				case ItemStat.frost_per_level:
					itemData.m_shared.m_damagesPerLevel.m_frost = updatedValue;
					break;
				case ItemStat.poison:
					itemData.m_shared.m_damages.m_poison = updatedValue;
					break;
				case ItemStat.poison_per_level:
					itemData.m_shared.m_damagesPerLevel.m_poison = updatedValue;
					break;
				case ItemStat.spirit:
					itemData.m_shared.m_damages.m_spirit = updatedValue;
					break;
				case ItemStat.spirit_per_level:
					itemData.m_shared.m_damagesPerLevel.m_spirit = updatedValue;
					break;
				case ItemStat.block_armor:
					itemData.m_shared.m_blockPower = updatedValue;
					break;
				case ItemStat.block_armor_per_level:
					itemData.m_shared.m_blockPowerPerLevel = updatedValue;
					break;
				case ItemStat.parry:
					itemData.m_shared.m_timedBlockBonus = updatedValue;
					break;
				case ItemStat.block_force:
					itemData.m_shared.m_deflectionForce = updatedValue;
					break;
				case ItemStat.block_force_per_level:
					itemData.m_shared.m_deflectionForcePerLevel = updatedValue;
					break;
				case ItemStat.primary_attack_stamina:
					itemData.m_shared.m_attack.m_attackStamina = updatedValue;
					break;
				case ItemStat.primary_attack_eitr:
					itemData.m_shared.m_attack.m_attackEitr = updatedValue;
					break;
				case ItemStat.primary_attack_flat_health_cost:
					itemData.m_shared.m_attack.m_attackHealth = updatedValue;
					break;
				case ItemStat.primary_attack_percent_health_cost:
					itemData.m_shared.m_attack.m_attackHealthPercentage = updatedValue;
					break;
				case ItemStat.primary_attack_health_returned:
					itemData.m_shared.m_attack.m_attackHealthReturnHit = updatedValue;
					break;
				case ItemStat.primary_attack_damage_bonus_per_missing_hp:
					itemData.m_shared.m_attack.m_damageMultiplierPerMissingHP = updatedValue;
					break;
				case ItemStat.primary_attack_projectile_count:
					itemData.m_shared.m_attack.m_projectiles = (int)updatedValue;
					break;
				case ItemStat.secondary_attack_stamina:
					itemData.m_shared.m_secondaryAttack.m_attackStamina = updatedValue;
					break;
				case ItemStat.secondary_attack_eitr:
					itemData.m_shared.m_secondaryAttack.m_attackEitr = updatedValue;
					break;
				case ItemStat.secondary_attack_flat_health_cost:
					itemData.m_shared.m_secondaryAttack.m_attackHealth = updatedValue;
					break;
				case ItemStat.secondary_attack_percent_health_cost:
					itemData.m_shared.m_secondaryAttack.m_attackHealthPercentage = updatedValue;
					break;
				case ItemStat.movement_speed:
					itemData.m_shared.m_movementModifier = updatedValue;
					break;
				case ItemStat.bow_draw_speed:
					itemData.m_shared.m_attack.m_drawDurationMin = updatedValue;
					break;
				case ItemStat.crossbow_reload_speed:
					itemData.m_shared.m_attack.m_reloadTime = updatedValue;
					break;
				case ItemStat.crossbow_reload_stamina_drain:
					itemData.m_shared.m_attack.m_reloadStaminaDrain = updatedValue;
					break;
				case ItemStat.draw_stamina_drain:
					itemData.m_shared.m_attack.m_drawStaminaDrain = updatedValue;
					break;
				case ItemStat.projectile_velocity:
					itemData.m_shared.m_attack.m_projectileVel = updatedValue;
					break;
				case ItemStat.projectile_accuracy_max:
					itemData.m_shared.m_attack.m_projectileAccuracy = 100f - updatedValue;
					break;
				case ItemStat.durability:
					itemData.m_shared.m_maxDurability = updatedValue;
					break;
				case ItemStat.durability_per_level:
					itemData.m_shared.m_durabilityPerLevel = updatedValue;
					break;
				case ItemStat.max_item_level:
					itemData.m_shared.m_maxQuality = (int)updatedValue;
					break;
				case ItemStat.tool_level:
					itemData.m_shared.m_toolTier = (int)updatedValue;
					break;
				default:
					Logger.LogWarning($"Unknown item stat {target_attribute} for {itemData.m_shared.m_name}");
					break;
				}
			}
		}

		private static bool ValidateRecipeConfig(ItemDefinition itemdef)
		{
			//IL_0096: 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_00a5: 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_00c8: Expected O, but got Unknown
			List<RequirementConfig> list = new List<RequirementConfig>();
			try
			{
				string[] array = itemdef.Recipe.RecipeConfig.Value.Split(new char[1] { '|' });
				foreach (string text in array)
				{
					string[] array2 = text.Split(new char[1] { ',' });
					if (array2.Length == 1)
					{
						return false;
					}
					if (array2.Length != 3)
					{
						Logger.LogWarning("Invalid (" + itemdef.Name + ") recipe config detected: " + text + ". Needs three entries eg: Wood,1,1");
						return false;
					}
					list.Add(new RequirementConfig
					{
						Item = array2[0],
						Amount = int.Parse(array2[1]),
						AmountPerLevel = int.Parse(array2[2])
					});
				}
				itemdef.Recipe.RecipeReqs = list;
				return true;
			}
			catch
			{
				Logger.LogWarning("Recipe is Invalid. Should have the format of Wood,1,1|Stone,2,0 - Prefab,cost,upgrade.");
				return false;
			}
		}

		private static void BuildRecipeReqsFromDefault(ItemDefinition itemdef)
		{
			//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_0033: 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_0050: Expected O, but got Unknown
			List<RequirementConfig> list = new List<RequirementConfig>();
			foreach (RecipeIngredient recipeItem in itemdef.Recipe.RecipeItems)
			{
				list.Add(new RequirementConfig
				{
					Item = recipeItem.Prefab,
					Amount = recipeItem.Amount,
					AmountPerLevel = recipeItem.UpgradeCost
				});
			}
			itemdef.Recipe.RecipeReqs = list;
		}

		private static string BuildStringRecipeFromItemDef(ItemDefinition itemdef)
		{
			List<string> list = new List<string>();
			foreach (RecipeIngredient recipeItem in itemdef.Recipe.RecipeItems)
			{
				list.Add($"{recipeItem.Prefab},{recipeItem.Amount},{recipeItem.UpgradeCost}");
			}
			return string.Join("|", list);
		}

		private static bool ModifyItemRecipeCraftedAt(ItemDefinition itemdef)
		{
			if ((Object)(object)ObjectDB.instance == (Object)null || ObjectDB.instance.m_recipes == null)
			{
				return false;
			}
			int recipeIndexByPrefab = GetRecipeIndexByPrefab(itemdef.Prefab);
			if (recipeIndexByPrefab == -1)
			{
				Logger.LogWarning("Recipe of " + itemdef.Prefab + " not found in ObjectDB, recipe will not be modified.");
				return false;
			}
			GameObject prefab = PrefabManager.Instance.GetPrefab(itemdef.CraftedAtCfg.Value);
			CraftingStation val = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogWarning("Crafting Station " + itemdef.CraftedAtCfg.Value + " prefab not found, or does not have a crafting station componet.");
				return false;
			}
			ObjectDB.instance.m_recipes[recipeIndexByPrefab].m_craftingStation = val;
			ObjectDB.instance.m_recipes[recipeIndexByPrefab].m_repairStation = val;
			return true;
		}

		private static void ModifyItemRecipeInODB(ItemDefinition itemdef)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_0117: Expected O, but got Unknown
			if ((Object)(object)ObjectDB.instance == (Object)null || ObjectDB.instance.m_recipes == null)
			{
				return;
			}
			int recipeIndexByPrefab = GetRecipeIndexByPrefab(itemdef.Prefab);
			if (recipeIndexByPrefab == -1)
			{
				Logger.LogWarning("Recipe of " + itemdef.Prefab + " not found in ObjectDB, Recipe will not be modified.");
				return;
			}
			Recipe val = ObjectDB.instance.m_recipes[recipeIndexByPrefab];
			Recipe val2 = val;
			List<Requirement> list = new List<Requirement>();
			foreach (RequirementConfig recipeReq in itemdef.Recipe.RecipeReqs)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(recipeReq.Item);
				if ((Object)(object)itemPrefab == (Object)null)
				{
					Logger.LogWarning("Recipe " + ((Object)itemdef.Recipe.ResolvedRecipe).name + " has an invalid requirement " + recipeReq.Item + ".");
					return;
				}
				list.Add(new Requirement
				{
					m_resItem = itemPrefab.GetComponent<ItemDrop>(),
					m_amount = recipeReq.Amount,
					m_amountPerLevel = recipeReq.AmountPerLevel
				});
			}
			val2.m_resources = list.ToArray();
			int num = ObjectDB.instance.m_recipes.IndexOf(val);
			if (num > -1)
			{
				ObjectDB.instance.m_recipes[num] = val2;
				itemdef.Recipe.ResolvedRecipe = val2;
			}
			else
			{
				Logger.LogWarning("Recipe " + ((Object)val).name + " not found in ObjectDB.");
			}
		}

		private static void EnsureRecipeInDB(ItemDefinition itemdef)
		{
			if (!((Object)(object)ObjectDB.instance == (Object)null) && ObjectDB.instance.m_recipes != null && GetRecipeIndexByPrefab(itemdef.Prefab) == -1 && (Object)(object)itemdef.Recipe.ResolvedRecipe != (Object)null)
			{
				ObjectDB.instance.m_recipes.Add(itemdef.Recipe.ResolvedRecipe);
			}
		}

		private static void EnableDisableItemInDB(ItemDefinition itemdef, bool enable)
		{
			if ((Object)(object)ObjectDB.instance == (Object)null || ObjectDB.instance.m_recipes == null)
			{
				return;
			}
			int recipeIndexByPrefab = GetRecipeIndexByPrefab(itemdef.Prefab);
			if (recipeIndexByPrefab == -1)
			{
				if ((Object)(object)itemdef.Recipe.ResolvedRecipe != (Object)null)
				{
					itemdef.Recipe.ResolvedRecipe.m_enabled = enable;
					ObjectDB.instance.m_recipes.Add(itemdef.Recipe.ResolvedRecipe);
				}
				else
				{
					Logger.LogWarning("Recipe of " + itemdef.Prefab + " not found in ObjectDB and no cached recipe to re-add.");
				}
			}
			else
			{
				ObjectDB.instance.m_recipes[recipeIndexByPrefab].m_enabled = enable;
				itemdef.Recipe.ResolvedRecipe = ObjectDB.instance.m_recipes[recipeIndexByPrefab];
			}
		}

		private static void ModifyItemRecipeLevel(ItemDefinition itemdef, int level)
		{
			if (!((Object)(object)ObjectDB.instance == (Object)null) && ObjectDB.instance.m_recipes != null)
			{
				int recipeIndexByPrefab = GetRecipeIndexByPrefab(itemdef.Prefab);
				if (recipeIndexByPrefab == -1)
				{
					Logger.LogWarning("Recipe of " + itemdef.Prefab + " not found in ObjectDB, required level will not be modified.");
					return;
				}
				ObjectDB.instance.m_recipes[recipeIndexByPrefab].m_minStationLevel = level;
				itemdef.Recipe.ResolvedRecipe = ObjectDB.instance.m_recipes[recipeIndexByPrefab];
			}
		}

		private static void ModifyItemRecipeCraftAmount(ItemDefinition itemdef, int amount)
		{
			if (!((Object)(object)ObjectDB.instance == (Object)null) && ObjectDB.instance.m_recipes != null)
			{
				int recipeIndexByPrefab = GetRecipeIndexByPrefab(itemdef.Prefab);
				if (recipeIndexByPrefab == -1)
				{
					Logger.LogWarning("Recipe of " + itemdef.Prefab + " not found in ObjectDB, craft amount will not be modified.");
					return;
				}
				ObjectDB.instance.m_recipes[recipeIndexByPrefab].m_amount = amount;
				itemdef.Recipe.ResolvedRecipe = ObjectDB.instance.m_recipes[recipeIndexByPrefab];
			}
		}

		private static int GetRecipeIndexByPrefab(string prefab)
		{
			return ObjectDB.instance.m_recipes.FindIndex((Recipe m) => (Object)(object)m.m_item != (Object)null && ((Object)m.m_item).name == prefab);
		}

		private static void SetItemDamageModifier(DamageModifier modifier, DamageType type, ItemData itemData)
		{
			//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_0079: 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_0082: 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_0054: 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_005d: 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)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			List<DamageModPair> list = itemData.m_shared.m_damageModifiers.Where((DamageModPair entry) => entry.m_type != type).ToList();
			if (list.Count == 0)
			{
				itemData.m_shared.m_damageModifiers.Clear();
				itemData.m_shared.m_damageModifiers.Add(new DamageModPair
				{
					m_modifier = modifier,
					m_type = type
				});
			}
			else
			{
				list.Add(new DamageModPair
				{
					m_modifier = modifier,
					m_type = type
				});
				itemData.m_shared.m_damageModifiers = list;
			}
		}

		private static void UpdateItemInPlayerInventory(string prefab, Action<ItemData> callback)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			foreach (ItemData allItem in ((Humanoid)Player.m_localPlayer).m_inventory.GetAllItems())
			{
				if (allItem != null && !(((Object)allItem.m_dropPrefab).name != prefab))
				{
					callback(allItem);
				}
			}
		}

		private static void EnqueueWorldUpdate(string prefab, Action<ItemData> callback)
		{
			ThreadingHelper instance = ThreadingHelper.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				pendingWorldUpdates.Add(new KeyValuePair<string, Action<ItemData>>(prefab, callback));
				if (!worldUpdateScheduled)
				{
					worldUpdateScheduled = true;
					((MonoBehaviour)instance).StartCoroutine(DrainWorldUpdates());
				}
			}
		}

		private static IEnumerator DrainWorldUpdates()
		{
			yield return null;
			try
			{
				if (pendingWorldUpdates.Count <= 0)
				{
					yield break;
				}
				GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
				ItemDrop val2 = default(ItemDrop);
				foreach (GameObject val in array)
				{
					if ((Object)(object)val == (Object)null || !val.TryGetComponent<ItemDrop>(ref val2))
					{
						continue;
					}
					foreach (KeyValuePair<string, Action<ItemData>> pendingWorldUpdate in pendingWorldUpdates)
					{
						if (((Object)val).name.StartsWith(pendingWorldUpdate.Key))
						{
							pendingWorldUpdate.Value(val2.m_itemData);
						}
					}
				}
			}
			finally
			{
				pendingWorldUpdates.Clear();
				worldUpdateScheduled = false;
			}
		}

		private static void AddAmmoItemsToArcheryTarget()
		{
			ArcheryTarget componentInChildren = PrefabManager.Instance.GetPrefab("piece_ArcheryTarget").GetComponentInChildren<ArcheryTarget>(true);
			foreach (string item in ArcheryAmmoToAdd)
			{
				Logger.LogDebug("Adding " + item + " to Archery Target Ammo Return.");
				ItemDrop component = PrefabManager.Instance.GetPrefab(item).GetComponent<ItemDrop>();
				if ((Object)(object)component != (Object)null && !componentInChildren.m_returnAmmo.Contains(component))
				{
					componentInChildren.m_returnAmmo.Add(component);
				}
			}
		}
	}
	internal enum ItemStat
	{
		slash,
		slash_per_level,
		blunt,
		blunt_per_level,
		pierce,
		pierce_per_level,
		pickaxe,
		pickaxe_per_level,
		chop,
		chop_per_level,
		attack_force,
		fire,
		fire_per_level,
		lightning,
		lightning_per_level,
		frost,
		frost_per_level,
		poison,
		poison_per_level,
		spirit,
		spirit_per_level,
		block_armor,
		block_armor_per_level,
		parry,
		block_force,
		block_force_per_level,
		primary_attack_stamina,
		primary_attack_eitr,
		primary_attack_flat_health_cost,
		primary_attack_percent_health_cost,
		primary_attack_health_returned,
		primary_attack_damage_bonus_per_missing_hp,
		primary_attack_projectile_count,
		primary_attack_force_multiply,
		secondary_attack_stamina,
		secondary_attack_eitr,
		secondary_attack_force_multiply,
		secondary_attack_flat_health_cost,
		secondary_attack_percent_health_cost,
		movement_speed,
		bow_draw_speed,
		crossbow_reload_speed,
		crossbow_reload_stamina_drain,
		draw_stamina_drain,
		projectile_velocity,
		projectile_accuracy_max,
		durability,
		durability_per_level,
		max_item_level,
		amount,
		tool_level
	}
	internal enum ItemCategory
	{
		Arrows,
		Atgeirs,
		Axes,
		Hammers,
		Shields,
		Swords,
		Bows,
		Spears,
		Knives,
		Maces,
		Fists,
		Pickaxes,
		Magics
	}
	internal class ItemDefinition
	{
		public string Name { get; set; }

		public string DisplayName { get; set; }

		public ItemCategory Category { get; set; }

		public string Prefab { get; set; }

		public string Icon { get; set; }

		public string CraftedAt { get; set; }

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

		public bool Craftable { get; set; } = true;

		public ConfigEntry<bool> CraftableCfg { get; set; }

		public int ReqStationlevel { get; set; }

		public ConfigEntry<int> StationLVLCfg { get; set; }

		public int CraftAmount { get; set; }

		public ConfigEntry<int> CraftAmountCfg { get; set; }

		public Dictionary<ItemStat, ItemStatConfig> ModifableStats { get; set; }

		public Dictionary<DamageType, HitCustomDamageMod> DamageMods { get; set; }

		public RecipeDefinition Recipe { get; set; }
	}
	internal class HitCustomDamageMod
	{
		public bool Configurable { get; set; } = true;

		public DamageModifier DamageModifier { get; set; }

		public ConfigEntry<string> DmgModCfg { get; set; }
	}
	internal class ItemStatConfig
	{
		public bool Configurable { get; set; } = true;

		public bool IsInt { get; set; }

		public float Default_value { get; set; }

		public ConfigEntry<float> Cfg { get; set; }

		public ConfigEntry<int> CfgInt { get; set; }

		public float Min { get; set; }

		public float Max { get; set; } = 400f;
	}
	internal class RecipeDefinition
	{
		public ConfigEntry<string> RecipeConfig { get; set; }

		public List<RecipeIngredient> RecipeItems { get; set; }

		public List<RequirementConfig> RecipeReqs { get; set; }

		public Recipe ResolvedRecipe { get; set; }
	}
	internal class RecipeIngredient
	{
		public string Prefab { get; set; }

		public int Amount { get; set; }

		public int UpgradeCost { get; set; }
	}
	public static class JotunnPiece
	{
		public class LoadedGameObjects
		{
			public GameObject Prefab { get; set; }

			public Sprite Sprite { get; set; }

			public GameObject ScenePrefab { get; set; }

			public Piece ScenePiece { get; set; }
		}

		public class PieceCost
		{
			public string Prefab { get; set; }

			public int Amount { get; set; }

			public bool Refundable { get; set; } = true;
		}

		public class PieceConfigs
		{
			public ConfigEntry<bool> Enabled { get; set; }

			public ConfigEntry<bool> RequiresWorkbench { get; set; }

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

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

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

			public List<PieceCost> UpdatedCost { get; set; } = new List<PieceCost>();
		}

		public class JotunnBuildPiece
		{
			public string Name { get; set; }

			public bool Enabled { get; set; } = true;

			public string Prefab { get; set; }

			public string Sprite { get; set; }

			public string Category { get; set; } = "Misc";

			public string Workbench { get; set; } = "piece_workbench";

			public List<PieceCost> PieceCost { get; set; } = new List<PieceCost>();

			public LoadedGameObjects Objs { get; set; }

			public PieceConfigs Cfgs { get; set; }
		}

		private static List<JotunnBuildPiece> BuildPieces = new List<JotunnBuildPiece>();

		private static bool PiecesReady = false;

		public static void RegisterJotunnPiece(JotunnBuildPiece jbuildpiece)
		{
			LoadedGameObjects loadedGameObjects = new LoadedGameObjects();
			loadedGameObjects.Prefab = CommunityPatchExtras.EmbeddedResourceBundle.LoadAsset<GameObject>(jbuildpiece.Prefab + ".prefab");
			loadedGameObjects.Sprite = CommunityPatchExtras.EmbeddedResourceBundle.LoadAsset<Sprite>(jbuildpiece.Sprite + ".png");
			jbuildpiece.Objs = loadedGameObjects;
			jbuildpiece.Cfgs = new PieceConfigs();
			InitialPieceSetup(jbuildpiece);
			BuildPieces.Add(jbuildpiece);
			PrefabManager.OnPrefabsRegistered += ResolveAndApplyScenePrefab;
			void ResolveAndApplyScenePrefab()
			{
				GameObject val = ResolveScenePrefab(jbuildpiece.Prefab);
				if ((Object)(object)val == (Object)null)
				{
					Logger.LogWarning("Could not find a scene prefab named '" + jbuildpiece.Prefab + "' with a Piece component after prefab registration; skipping in-place setup for " + jbuildpiece.Name + ".");
				}
				else
				{
					jbuildpiece.Objs.ScenePrefab = val;
					jbuildpiece.Objs.ScenePiece = val.GetComponent<Piece>();
					PiecesReady = true;
					ApplyWorkbench(jbuildpiece);
					ApplyCategory(jbuildpiece);
					ApplyRecipe(jbuildpiece);
				}
			}
		}

		private static GameObject ResolveScenePrefab(string prefabName)
		{
			GameObject prefab = PrefabManager.Instance.GetPrefab(prefabName);
			if ((Object)(object)prefab != (Object)null && (Object)(object)prefab.GetComponent<Piece>() != (Object)null)
			{
				return prefab;
			}
			List<GameObject> list = (from obj in Resources.FindObjectsOfTypeAll<GameObject>()
				where ((Object)obj).name == prefabName && (Object)(object)obj.GetComponent<Piece>() != (Object)null
				select obj).ToList();
			if (ValConfig.EnableDebugMode.Value)
			{
				Logger.LogInfo($"Found {list.Count} scene object(s) named '{prefabName}' with a Piece component.");
			}
			return list.FirstOrDefault();
		}

		private static void InitialPieceSetup(JotunnBuildPiece jbuildpiece)
		{
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Expected O, but got Unknown
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Expected O, but got Unknown
			jbuildpiece.Cfgs.Workbench = ValConfig.BindServerConfig(jbuildpiece.Name ?? "", "Workbench", jbuildpiece.Workbench, "The table required to allow building this piece, eg: 'forge', 'piece_workbench', 'blackforge', 'piece_artisanstation'.");
			jbuildpiece.Cfgs.Workbench.SettingChanged += RequiredBench_SettingChanged;
			jbuildpiece.Cfgs.Enabled = ValConfig.BindServerConfig(jbuildpiece.Name ?? "", "Enabled", jbuildpiece.Enabled, "Enable/Disable the " + jbuildpiece.Name + ".");
			jbuildpiece.Cfgs.Enabled.SettingChanged += BuildRecipeChanged_SettingChanged;
			jbuildpiece.Cfgs.PieceCategory = ValConfig.BindServerConfig(jbuildpiece.Name ?? "", "Piece Category", jbuildpiece.Category, "Piece category for building.", PieceCategories.GetAcceptableValueList());
			jbuildpiece.Cfgs.PieceCategory.SettingChanged += CraftingCategory_SettingChanged;
			List<string> list = new List<string>();
			foreach (PieceCost item in jbuildpiece.PieceCost)
			{
				list.Add($"{item.Prefab},{item.Amount},{item.Refundable}");
			}
			string text = string.Join("|", list);
			jbuildpiece.Cfgs.PieceCost = ValConfig.BindServerConfig(jbuildpiece.Name ?? "", "Building Cost", text, "Cost to build. Find item ids: https://valheim.fandom.com/wiki/Item_IDs Format: resouce_id,amount,refund eg: Wood,8,true|LeatherScraps,4,false", null, advanced: true);
			if (!PieceRecipeConfigUpdater(jbuildpiece, jbuildpiece.Cfgs.PieceCost.Value, during_runtime: false))
			{
				Logger.LogWarning(jbuildpiece.Name + " has an invalid piece cost. The default will be used instead.");
				PieceRecipeConfigUpdater(jbuildpiece, text, during_runtime: false);
			}
			jbuildpiece.Cfgs.PieceCost.SettingChanged += BuildRecipeChanged_SettingChanged;
			PieceConfigDrawer.Attach(jbuildpiece);
			List<RequirementConfig> list2 = new List<RequirementConfig>();
			foreach (PieceCost item2 in jbuildpiece.Cfgs.UpdatedCost)
			{
				list2.Add(new RequirementConfig
				{
					Item = item2.Prefab,
					Amount = item2.Amount,
					Recover = item2.Refundable
				});
			}
			PieceConfig val = new PieceConfig
			{
				CraftingStation = jbuildpiece.Cfgs.Workbench.Value,
				PieceTable = PieceTables.Hammer,
				Category = jbuildpiece.Cfgs.PieceCategory.Value,
				Icon = jbuildpiece.Objs.Sprite,
				Requirements = list2.ToArray()
			};
			PieceManager.Instance.AddPiece(new CustomPiece(jbuildpiece.Objs.Prefab, true, val));
			void BuildRecipeChanged_SettingChanged(object sender, EventArgs e)
			{
				if (PiecesReady && !((Object)(object)jbuildpiece.Objs.ScenePiece == (Object)null))
				{
					ConfigChangeDebouncer.Schedule(sender, delegate
					{
						if (sender.GetType() == typeof(ConfigEntry<string>))
						{
							ConfigEntry<string> val2 = (ConfigEntry<string>)sender;
							if (ValConfig.EnableDebugMode.Value)
							{
								Logger.LogInfo("Recieved new piece config " + val2.Value);
							}
							if (!PieceRecipeConfigUpdater(jbuildpiece, val2.Value))
							{
								return;
							}
						}
						ApplyRecipe(jbuildpiece);
					});
				}
			}
			void CraftingCategory_SettingChanged(object sender, EventArgs e)
			{
				if (PiecesReady && !((Object)(object)jbuildpiece.Objs.ScenePiece == (Object)null))
				{
					ConfigChangeDebouncer.Schedule(jbuildpiece.Cfgs.PieceCategory, delegate
					{
						ApplyCategory(jbuildpiece);
					});
				}
			}
			void RequiredBench_SettingChanged(object sender, EventArgs e)
			{
				if (PiecesReady && !((Object)(object)jbuildpiece.Objs.ScenePiece == (Object)null))
				{
					ConfigChangeDebouncer.Schedule(jbuildpiece.Cfgs.Workbench, delegate
					{
						ApplyWorkbench(jbuildpiece);
					});
				}
			}
		}

		private static void ApplyWorkbench(JotunnBuildPiece jbuildpiece)
		{
			Piece scenePiece = jbuildpiece.Objs.ScenePiece;
			if ((Object)(object)scenePiece == (Object)null)
			{
				return;
			}
			ConfigEntry<bool> requiresWorkbench = jbuildpiece.Cfgs.RequiresWorkbench;
			if ((requiresWorkbench != null && !requiresWorkbench.Value) || string.IsNullOrEmpty(jbuildpiece.Cfgs.Workbench.Value) || jbuildpiece.Cfgs.Workbench.Value.ToLower() == "none")
			{
				Logger.LogInfo("Setting required crafting station to none.");
				scenePiece.m_craftingStation = null;
				return;
			}
			GameObject prefab = PrefabManager.Instance.GetPrefab(jbuildpiece.Cfgs.Workbench.Value);
			CraftingStation val = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogWarning("Required crafting station does not exist or does not have a crafting station component, check your prefab name (" + jbuildpiece.Cfgs.Workbench.Value + ").");
				return;
			}
			if (ValConfig.EnableDebugMode.Value)
			{
				Logger.LogInfo("Setting crafting station to " + jbuildpiece.Cfgs.Workbench.Value + ".");
			}
			scenePiece.m_craftingStation = val;
		}

		private static void ApplyCategory(JotunnBuildPiece jbuildpiece)
		{
			//IL_005e: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			Piece scenePiece = jbuildpiece.Objs.ScenePiece;
			if (!((Object)(object)scenePiece == (Object)null))
			{
				PieceCategory? val = PieceManager.Instance.GetPieceCategory(jbuildpiece.Cfgs.PieceCategory.Value);
				if (!val.HasValue)
				{
					val = PieceManager.Instance.AddPieceCategory(jbuildpiece.Cfgs.PieceCategory.Value);
				}
				scenePiece.m_category = val.Value;
			}
		}

		private static void ApplyRecipe(JotunnBuildPiece jbuildpiece)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00f4: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			Piece scenePiece = jbuildpiece.Objs.ScenePiece;
			if ((Object)(object)scenePiece == (Object)null)
			{
				return;
			}
			List<RequirementConfig> list = new List<RequirementConfig>();
			if (ValConfig.EnableDebugMode.Value)
			{
				Logger.LogInfo("Validating and building requirementsConfig");
			}
			foreach (PieceCost item in jbuildpiece.Cfgs.UpdatedCost)
			{
				if ((Object)(object)PrefabManager.Instance.GetPrefab(item.Prefab) == (Object)null)
				{
					if (ValConfig.EnableDebugMode.Value)
					{
						Logger.LogInfo(item.Prefab + " is not a valid prefab, skipping recipe update.");
					}
					return;
				}
				if (ValConfig.EnableDebugMode.Value)
				{
					Logger.LogInfo($"Checking entry {item.Prefab} amount:{item.Amount} refund?:{item.Refundable}");
				}
				list.Add(new RequirementConfig
				{
					Item = item.Prefab,
					Amount = item.Amount,
					Recover = item.Refundable
				});
			}
			if (jbuildpiece.Cfgs.Enabled.Value)
			{
				if (ValConfig.EnableDebugMode.Value)
				{
					Logger.LogInfo("Updating Piece.");
				}
				List<Requirement> list2 = new List<Requirement>();
				foreach (RequirementConfig item2 in list)
				{
					Requirement val = new Requirement();
					GameObject prefab = PrefabManager.Instance.GetPrefab(item2.Item.Replace("JVLmock_", ""));
					val.m_resItem = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
					val.m_amount = item2.Amount;
					val.m_recover = item2.Recover;
					list2.Add(val);
				}
				if (ValConfig.EnableDebugMode.Value)
				{
					Logger.LogInfo($"Fixed mock requirements {list2.Count}.");
				}
				scenePiece.m_resources = list2.ToArray();
				if (ValConfig.EnableDebugMode.Value)
				{
					Logger.LogInfo($"New requirements set {scenePiece.m_resources}.");
				}
			}
			else
			{
				scenePiece.m_enabled = false;
			}
		}

		private static bool PieceRecipeConfigUpdater(JotunnBuildPiece jBuildPiece, string rawRecipe, bool during_runtime = true)
		{
			string[] array = rawRecipe.Split(new char[1] { '|' });
			List<PieceCost> list = new List<PieceCost>();
			if (array.Length >= 1)
			{
				string[] array2 = array;
				foreach (string text in array2)
				{
					string[] array3 = text.Split(new char[1] { ',' });
					if (array3.Length != 3)
					{
						Logger.LogWarning(text + " is invalid, it does not have enough segments. Proper format is: PREFABNAME,COST,REFUND_BOOL eg: Wood,8,false");
						return false;
					}
					if (ValConfig.EnableDebugMode.Value)
					{
						string text2 = "";
						string[] array4 = array3;
						foreach (string text3 in array4)
						{
							text2 = text2 + " " + text3;
						}
					}
					if (during_runtime && (Object)(object)PrefabManager.Instance.GetPrefab(array3[0]) == (Object)null)
					{
						Logger.LogWarning(array3[0] + " is an invalid prefab and does not exist.");
						return false;
					}
					if (array3[0].Length == 0 || array3[1].Length == 0 || array3[2].Length == 0)
					{
						Logger.LogWarning(text + " is invalid, one segment does not have enough data. Proper format is: PREFABNAME,CRAFT_COST,REFUND_BOOL eg: Wood,8,false");
						return false;
					}
					if (!bool.TryParse(array3[2], out var result))
					{
						Logger.LogWarning(text + " is invalid, the REFUND_BOOL could not be parsed to (true/false). Proper format is: PREFABNAME,CRAFT_COST,REFUND_BOOL eg: Wood,8,false");
						return false;
					}
					if (ValConfig.EnableDebugMode.Value)
					{
						Logger.LogInfo("prefab: " + array3[0] + " c:" + array3[1] + " u:" + array3[2]);
					}
					list.Add(new PieceCost
					{
						Prefab = array3[0],
						Amount = int.Parse(array3[1]),
						Refundable = result
					});
				}
				jBuildPiece.Cfgs.UpdatedCost.Clear();
				foreach (PieceCost item in list)
				{
					jBuildPiece.Cfgs.UpdatedCost.Add(item);
				}
				if (ValConfig.EnableDebugMode.Value)
				{
					string text4 = "";
					foreach (PieceCost item2 in list)
					{
						text4 += $" {item2.Prefab} c:{item2.Amount} r:{item2.Refundable}";
					}
					Logger.LogInfo("Updated recipe:" + text4);
				}
				return true;
			}
			Logger.LogWarning("Invalid recipe: " + rawRecipe + ". defaults will be used. Check your prefab names.");
			jBuildPiece.Cfgs.UpdatedCost = jBuildPiece.PieceCost;
			return false;
		}
	}
	internal static class LocalizationLoader
	{
		internal static string LocalizationFolder = "Localizations";

		internal static void AddLocalizations()
		{
			CustomLocalization localization = CommunityPatchExtras.Localization;
			string text = Path.Combine(Paths.ConfigPath, ValConfig.cfgFolder, LocalizationFolder);
			Directory.CreateDirectory(text);
			string[] manifestResourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
			foreach (string text2 in manifestResourceNames)
			{
				if (!text2.Contains(LocalizationFolder))
				{
					continue;
				}
				string text3 = Regex.Replace(ReadEmbeddedResourceFile(text2), "\\/\\/.*", "");
				Dictionary<string, string> internal_localization = SimpleJson.DeserializeObject<Dictionary<string, string>>(text3);
				string[] array = text2.Split(new char[1] { '.' });
				if (File.Exists(text + "/" + array[2] + ".json"))
				{
					string text4 = File.ReadAllText(text + "/" + array[2] + ".json");
					try
					{
						Dictionary<string, string> dictionary = SimpleJson.DeserializeObject<Dictionary<string, string>>(text4);
						UpdateLocalizationWithMissingKeys(internal_localization, dictionary);
						Logger.LogDebug("Reading " + text + "/" + array[2] + ".json");
						File.WriteAllText(text + "/" + array[2] + ".json", SimpleJson.SerializeObject((object)dictionary));
						string text5 = File.ReadAllText(text + "/" + array[2] + ".json");
						localization.AddJsonFile(array[2], text5);
					}
					catch
					{
						File.WriteAllText(text + "/" + array[2] + ".json", text3);
						Logger.LogDebug("Reading " + text2);
						localization.AddJsonFile(array[2], text3);
					}
				}
				else
				{
					File.WriteAllText(text + "/" + array[2] + ".json", text3);
					Logger.LogDebug("Reading " + text2);
					localization.AddJsonFile(array[2], text3);
				}
				Logger.LogDebug("Added localization: '" + array[2] + "'");
			}
		}

		private static Dictionary<string, string> UpdateLocalizationWithMissingKeys(Dictionary<string, string> internal_localization, Dictionary<string, string> cached_localization)
		{
			if (internal_localization.Keys != cached_localization.Keys)
			{
				List<string> list = cached_localization.Keys.ToList();
				foreach (KeyValuePair<string, string> item in internal_localization)
				{
					list.Remove(item.Key);
					if (!cached_localization.ContainsKey(item.Key))
					{
						Logger.LogDebug("Adding missing localization key " + item.Key);
						cached_localization.Add(item.Key, item.Value);
					}
				}
				if (list.Count > 0)
				{
					Logger.LogDebug("Removing extra keys " + string.Join(",", list) + ".");
					foreach (string item2 in list)
					{
						cached_localization.Remove(item2);
					}
				}
			}
			return cached_localization;
		}

		private static string ReadEmbeddedResourceFile(string filename)
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(filename);
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}
	}
}