using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using AlmanacClasses.API;
using AzuExtendedPlayerInventory;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Deathlink.Common;
using Deathlink.Death;
using Deathlink.external;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using SimpleJson;
using Splatform;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ValRougelike")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValRougelike")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Backpacks
{
	[PublicAPI]
	public static class API
	{
		public static EpicMMOSystem_API.API_State state;

		private static MethodInfo eCountItemsInBackpacks;

		private static MethodInfo eAddItemToBackpack;

		private static MethodInfo eDeleteItemsFromBackpacks;

		private static MethodInfo eGetEquippedBackpackInventory;

		private static MethodInfo eGetAllBackpackInventories;

		public static int CountItemsInBackpacks(Inventory inventory, string name, bool onlyRemoveable = true)
		{
			return (int)eCountItemsInBackpacks?.Invoke(null, new object[3] { inventory, name, onlyRemoveable });
		}

		public static bool IsItemInBackpacks(Inventory inventory, string name)
		{
			return CountItemsInBackpacks(inventory, name) > 0;
		}

		public static bool AddItemToBackpack(ItemData backpack, ItemData item)
		{
			return (bool)eAddItemToBackpack?.Invoke(null, new object[2] { backpack, item });
		}

		public static bool DeleteItemsFromBackpacks(Inventory inventory, string name, int count = 1)
		{
			return (bool)eDeleteItemsFromBackpacks?.Invoke(null, new object[3] { inventory, name, count });
		}

		public static Inventory? GetEquippedBackpackInventory()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			return (Inventory)(eGetEquippedBackpackInventory?.Invoke(null, new object[0]));
		}

		public static List<Inventory> GetAllBackpackInventories(Inventory inventory)
		{
			return (List<Inventory>)(eGetAllBackpackInventories?.Invoke(null, new object[1] { inventory }));
		}

		public static void Init()
		{
			EpicMMOSystem_API.API_State aPI_State = state;
			if ((uint)(aPI_State - 1) > 1u)
			{
				if (Type.GetType("Backpacks.API, Backpacks") == null)
				{
					state = EpicMMOSystem_API.API_State.NotInstalled;
					return;
				}
				state = EpicMMOSystem_API.API_State.Ready;
				Type? type = Type.GetType("Backpacks.API, Backpacks");
				eCountItemsInBackpacks = type.GetMethod("CountItemsInBackpacks", BindingFlags.Static | BindingFlags.Public);
				eAddItemToBackpack = type.GetMethod("AddItemToBackpack", BindingFlags.Static | BindingFlags.Public);
				eDeleteItemsFromBackpacks = type.GetMethod("DeleteItemsFromBackpacks", BindingFlags.Static | BindingFlags.Public);
				eGetEquippedBackpackInventory = type.GetMethod("GetEquippedBackpackInventory", BindingFlags.Static | BindingFlags.Public);
				eGetAllBackpackInventories = type.GetMethod("GetAllBackpackInventories", BindingFlags.Static | BindingFlags.Public);
			}
		}
	}
}
namespace AzuExtendedPlayerInventory
{
	[PublicAPI]
	public class API
	{
		public delegate void SlotAddedHandler(string slotName);

		public delegate void SlotRemovedHandler(string slotName);

		public static event Action<Hud>? OnHudAwake;

		public static event Action<Hud>? OnHudAwakeComplete;

		public static event Action<Hud>? OnHudUpdate;

		public static event Action<Hud>? OnHudUpdateComplete;

		public static event SlotAddedHandler? SlotAdded;

		public static event SlotRemovedHandler? SlotRemoved;

		public static bool IsLoaded()
		{
			return false;
		}

		public static bool AddSlot(string slotName, Func<Player, ItemData?> getItem, Func<ItemData, bool> isValid, int index = -1)
		{
			return false;
		}

		public static bool RemoveSlot(string slotName)
		{
			return false;
		}

		public static SlotInfo GetSlots()
		{
			return new SlotInfo();
		}

		public static SlotInfo GetQuickSlots()
		{
			return new SlotInfo();
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			return new List<ItemData>();
		}

		public static int GetAddedRows(int width)
		{
			return 0;
		}
	}
	[PublicAPI]
	public class SlotInfo
	{
		public string[] SlotNames { get; set; } = new string[0];

		public Vector2[] SlotPositions { get; set; } = (Vector2[])(object)new Vector2[0];

		public Func<Player, ItemData?>?[] GetItemFuncs { get; set; } = new Func<Player, ItemData>[0];

		public Func<ItemData, bool>?[] IsValidFuncs { get; set; } = new Func<ItemData, bool>[0];
	}
}
namespace AlmanacClasses.API
{
	public static class ClassesAPI
	{
		private static readonly MethodInfo? API_AddExperience;

		private static readonly MethodInfo? API_GetLevel;

		private static readonly MethodInfo? API_GetCharacteristic;

		public static void AddEXP(int amount)
		{
			API_AddExperience?.Invoke(null, new object[1] { amount });
		}

		public static int GetLevel()
		{
			return (int)(API_GetLevel?.Invoke(null, null) ?? ((object)0));
		}

		public static int GetCharacteristic(string type)
		{
			return (int)(API_GetCharacteristic?.Invoke(null, new object[1] { type }) ?? ((object)0));
		}

		public static int GetConstitution()
		{
			return GetCharacteristic("Constitution");
		}

		public static int GetDexterity()
		{
			return GetCharacteristic("Dexterity");
		}

		public static int GetStrength()
		{
			return GetCharacteristic("Strength");
		}

		public static int GetIntelligence()
		{
			return GetCharacteristic("Intelligence");
		}

		public static int GetWisdom()
		{
			return GetCharacteristic("Wisdom");
		}

		static ClassesAPI()
		{
			Type type = Type.GetType("AlmanacClasses.API.API, AlmanacClasses");
			if ((object)type != null)
			{
				API_AddExperience = type.GetMethod("AddExperience", BindingFlags.Static | BindingFlags.Public);
				API_GetLevel = type.GetMethod("GetLevel", BindingFlags.Static | BindingFlags.Public);
				API_GetCharacteristic = type.GetMethod("GetCharacteristic", BindingFlags.Static | BindingFlags.Public);
			}
		}
	}
}
namespace Deathlink
{
	internal class Logger
	{
		public static LogLevel Level = (LogLevel)16;

		public static void enableDebugLogging(object sender, EventArgs e)
		{
			//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 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 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)
			{
				Deathlink.Log.LogInfo((object)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)
			{
				Deathlink.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)
			{
				Deathlink.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)
			{
				Deathlink.Log.LogError((object)message);
			}
		}
	}
	public static class Extensions
	{
		private static readonly List<ItemType> EquipmentTypes = new List<ItemType>
		{
			(ItemType)7,
			(ItemType)12,
			(ItemType)6,
			(ItemType)11,
			(ItemType)4,
			(ItemType)5,
			(ItemType)19,
			(ItemType)17,
			(ItemType)18,
			(ItemType)3,
			(ItemType)14,
			(ItemType)22,
			(ItemType)20,
			(ItemType)24
		};

		public static List<ItemData> GetEquipment(this List<ItemData> list)
		{
			return list.Where((ItemData x) => EquipmentTypes.Contains(x.m_shared.m_itemType)).ToList();
		}

		public static List<ItemData> GetNotEquipment(this List<ItemData> list)
		{
			return list.Where((ItemData x) => !EquipmentTypes.Contains(x.m_shared.m_itemType)).ToList();
		}

		public static bool IsEquipment(this ItemData item)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (EquipmentTypes.Contains(item.m_shared.m_itemType))
			{
				return true;
			}
			return false;
		}
	}
	[BepInPlugin("MidnightsFX.Deathlink", "Deathlink", "0.10.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class Deathlink : BaseUnityPlugin
	{
		public const string PluginGUID = "MidnightsFX.Deathlink";

		public const string PluginName = "Deathlink";

		public const string PluginVersion = "0.10.2";

		public ValConfig cfg;

		internal static AssetBundle EmbeddedResourceBundle;

		internal static bool AzuEPILoaded = false;

		internal static bool RustyAlmanacClassesLoaded = false;

		internal static bool WackyMMOLoaded = false;

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

		public static ManualLogSource Log;

		public void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			cfg = new ValConfig(((BaseUnityPlugin)this).Config);
			AddLocalizations();
			EmbeddedResourceBundle = AssetUtils.LoadAssetBundleFromResources("Deathlink.AssetsEmbedded.deathless", typeof(Deathlink).Assembly);
			DeathProgressionSkill.SetupDeathSkill();
			if (API.IsLoaded())
			{
				AzuEPILoaded = true;
			}
			if (Enumerable.Contains(BepInExUtils.GetPlugins(false).Keys, "WackyMole.EpicMMOSystem"))
			{
				EpicMMOSystem_API.Init();
				if (EpicMMOSystem_API.state == EpicMMOSystem_API.API_State.Ready)
				{
					WackyMMOLoaded = true;
					((BaseUnityPlugin)this).Logger.LogInfo((object)"WackMMO API loaded.");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)"WackMMO API installed but API not ready.");
				}
			}
			if (Enumerable.Contains(BepInExUtils.GetPlugins(false).Keys, "RustyMods.AlmanacClasses"))
			{
				RustyAlmanacClassesLoaded = true;
			}
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), (string)null);
			DeathConfigurationData.Init();
			LeaderboardData.Init();
			((MonoBehaviour)this).StartCoroutine(LeaderboardData.SyncLoop());
			TerminalCommands.AddCommands();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Death is not the end.");
		}

		public static DataObjects.DeathChoiceLevel pcfg()
		{
			return DeathConfigurationData.playerDeathConfiguration;
		}

		private void AddLocalizations()
		{
			Localization = LocalizationManager.Instance.GetLocalization();
			string text = Path.Combine(Paths.ConfigPath, "Deathlink", "localizations");
			Directory.CreateDirectory(text);
			string[] manifestResourceNames = typeof(Deathlink).Assembly.GetManifestResourceNames();
			foreach (string text2 in manifestResourceNames)
			{
				if (!text2.Contains("Localizations"))
				{
					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);
						((BaseUnityPlugin)this).Logger.LogDebug((object)("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);
						((BaseUnityPlugin)this).Logger.LogDebug((object)("Reading " + text2));
						Localization.AddJsonFile(array[2], text3);
					}
				}
				else
				{
					File.WriteAllText(text + "/" + array[2] + ".json", text3);
					((BaseUnityPlugin)this).Logger.LogDebug((object)("Reading " + text2));
					Localization.AddJsonFile(array[2], text3);
				}
				((BaseUnityPlugin)this).Logger.LogDebug((object)("Added localization: '" + array[2] + "'"));
			}
		}

		private void UpdateLocalizationWithMissingKeys(Dictionary<string, string> internal_localization, Dictionary<string, string> cached_localization)
		{
			if (internal_localization.Keys.Count == cached_localization.Keys.Count)
			{
				return;
			}
			((BaseUnityPlugin)this).Logger.LogDebug((object)"Cached localization was missing some entries. They will be added.");
			foreach (KeyValuePair<string, string> item in internal_localization)
			{
				if (!cached_localization.ContainsKey(item.Key))
				{
					cached_localization.Add(item.Key, item.Value);
				}
			}
		}

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

		public static List<T> shuffleList<T>(List<T> inputList)
		{
			int i = 0;
			int count = inputList.Count;
			int num = 0;
			T val = default(T);
			List<T> list = new List<T>();
			list.AddRange(inputList);
			for (; i < count; i++)
			{
				num = Random.Range(i, list.Count);
				val = list[i];
				list[i] = list[num];
				list[num] = val;
			}
			return list;
		}
	}
}
namespace Deathlink.external
{
	public static class EpicMMOSystem_API
	{
		public enum API_State
		{
			NotReady,
			NotInstalled,
			Ready
		}

		public enum Attribut
		{
			Strength,
			Agility,
			Intellect,
			Body,
			Vigour,
			Special
		}

		public static API_State state;

		private static MethodInfo eGetLevel;

		private static MethodInfo eAddExp;

		private static MethodInfo eGetAttribute;

		private static MethodInfo eGetAttributeRusty;

		private static MethodInfo eSetSingleRate;

		public static int GetLevel()
		{
			int result = 0;
			Init();
			if (eGetLevel != null)
			{
				result = (int)eGetLevel.Invoke(null, null);
			}
			return result;
		}

		public static int GetAttribute(Attribut attribute)
		{
			int result = 0;
			Init();
			if (eGetAttribute != null)
			{
				result = (int)eGetAttribute.Invoke(null, new object[1] { attribute });
			}
			return result;
		}

		public static int GetAttributeRusty(string attribute)
		{
			int result = 0;
			Init();
			if (eGetAttributeRusty != null)
			{
				result = (int)eGetAttributeRusty.Invoke(null, new object[1] { attribute });
			}
			return result;
		}

		public static void AddExp(int value)
		{
			Init();
			eAddExp?.Invoke(null, new object[1] { value });
		}

		public static void SetSingleRate(float rate)
		{
			Init();
			eSetSingleRate?.Invoke(null, new object[1] { rate });
		}

		public static void Init()
		{
			API_State aPI_State = state;
			if ((uint)(aPI_State - 1) > 1u)
			{
				if (Type.GetType("EpicMMOSystem.EpicMMOSystem, EpicMMOSystem") == null)
				{
					state = API_State.NotInstalled;
					return;
				}
				state = API_State.Ready;
				Type? type = Type.GetType("API.EMMOS_API, EpicMMOSystem");
				eGetLevel = type.GetMethod("GetLevel", BindingFlags.Static | BindingFlags.Public);
				eAddExp = type.GetMethod("AddExp", BindingFlags.Static | BindingFlags.Public);
				eGetAttribute = type.GetMethod("GetAttribute", BindingFlags.Static | BindingFlags.Public);
				eGetAttributeRusty = type.GetMethod("GetAttribute", BindingFlags.Static | BindingFlags.Public);
				eSetSingleRate = type.GetMethod("SetSingleRate", BindingFlags.Static | BindingFlags.Public);
			}
		}
	}
}
namespace Deathlink.Death
{
	public static class Compendium
	{
		[HarmonyPatch(typeof(TextsDialog), "UpdateTextsList")]
		public static class TextsDialog_UpdateTextsList_Patch
		{
			public static void Postfix(TextsDialog __instance)
			{
				AddDeathLinkExplanationPage(__instance);
			}

			private static void AddDeathLinkExplanationPage(TextsDialog textsDialog)
			{
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Expected O, but got Unknown
				DataObjects.DeathChoiceLevel playerDeathConfiguration = DeathConfigurationData.playerDeathConfiguration;
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("<size=48>" + Localization.instance.Localize("$comp_header") + ": <color=" + specialColor + ">" + playerDeathConfiguration.DisplayName + "</color></size>");
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("<size=30><b>Death Effects</b></size>");
				stringBuilder.AppendLine(playerDeathConfiguration.GetDeathStyleDescription());
				stringBuilder.AppendLine();
				if (playerDeathConfiguration.DamageTakenModifier != 1f || playerDeathConfiguration.DamageDoneModifier != 1f)
				{
					stringBuilder.AppendLine("<size=30><b>Combat Modifiers</b></size>");
					stringBuilder.AppendLine(playerDeathConfiguration.GetDamageModifierDescription());
					stringBuilder.AppendLine();
				}
				if (playerDeathConfiguration.SkillModifiers != null && playerDeathConfiguration.SkillModifiers.Count > 0)
				{
					stringBuilder.AppendLine("<size=30><b>Skill Modifiers</b></size>");
					stringBuilder.AppendLine(playerDeathConfiguration.GetSkillModiferDescription());
					stringBuilder.AppendLine();
				}
				if (playerDeathConfiguration.ResourceModifiers != null && playerDeathConfiguration.ResourceModifiers.Count > 0)
				{
					stringBuilder.AppendLine("<size=30><b>Resource Modifiers</b></size>");
					stringBuilder.AppendLine(playerDeathConfiguration.GetResourceModiferDescription());
					stringBuilder.AppendLine();
				}
				if (playerDeathConfiguration.DeathLootModifiers != null && playerDeathConfiguration.DeathLootModifiers.Count > 0)
				{
					stringBuilder.AppendLine("<size=30><b>Loot Modifiers</b></size>");
					stringBuilder.AppendLine(playerDeathConfiguration.GetLootModifiersDescription());
					stringBuilder.AppendLine();
				}
				textsDialog.m_texts.Insert(0, new TextInfo(Localization.instance.Localize("$deathlink_settings"), Localization.instance.Localize(stringBuilder.ToString())));
			}
		}

		[HarmonyPatch(typeof(TextsDialog), "ShowText", new Type[] { typeof(TextInfo) })]
		public static class TextsDialog_ShowText_Patch
		{
			public static void Postfix(TextsDialog __instance, TextInfo text)
			{
				bool flag = text != null && text.m_topic == Localization.instance.Localize("$deathlink_settings");
				bool flag2 = flag && DeathConfigurationData.PlayerCanChangeChoice(Player.m_localPlayer);
				Logger.LogDebug($"TextsDialog.ShowText topic='{text?.m_topic}' isDeathlinkPage={flag} canChange={flag2}");
				if (!flag2)
				{
					if ((Object)(object)changeChoiceButton != (Object)null)
					{
						changeChoiceButton.SetActive(false);
					}
					return;
				}
				EnsureChangeChoiceButton(__instance);
				if ((Object)(object)changeChoiceButton != (Object)null)
				{
					changeChoiceButton.SetActive(true);
					changeChoiceButton.transform.SetAsLastSibling();
				}
			}

			private static void EnsureChangeChoiceButton(TextsDialog dialog)
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Expected O, but got Unknown
				if ((Object)(object)changeChoiceButton != (Object)null)
				{
					return;
				}
				if (GUIManager.Instance == null)
				{
					Logger.LogWarning("GUIManager not setup, skipping death choice change button creation.");
					return;
				}
				Transform val = ((Component)dialog).transform.Find("Texts_frame/Closebutton");
				changeChoiceButton = GUIManager.Instance.CreateButton(Localization.instance.Localize("$comp_change_choice"), val, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(300f, 0f), 200f, 40f);
				((UnityEvent)changeChoiceButton.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					dialog.OnClose();
					DeathChoices.DeathChoiceUI.Instance.ShowForChange();
				});
			}

			private static RectTransform FindCloseButton(TextsDialog dialog)
			{
				Button val = null;
				Button[] componentsInChildren = ((Component)dialog).GetComponentsInChildren<Button>(true);
				foreach (Button val2 in componentsInChildren)
				{
					if ((Object)(object)((Component)val2).gameObject == (Object)(object)changeChoiceButton)
					{
						continue;
					}
					for (int j = 0; j < ((UnityEventBase)val2.onClick).GetPersistentEventCount(); j++)
					{
						if (((UnityEventBase)val2.onClick).GetPersistentMethodName(j) == "OnClose")
						{
							return ((Component)val2).GetComponent<RectTransform>();
						}
					}
					if ((Object)(object)val == (Object)null && ((Object)val2).name.IndexOf("close", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						val = val2;
					}
				}
				if (!((Object)(object)val != (Object)null))
				{
					return null;
				}
				return ((Component)val).GetComponent<RectTransform>();
			}
		}

		private static string specialColor = "#ffa64d";

		private static GameObject changeChoiceButton;
	}
	public static class DamageModifiers
	{
		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		public static class DamageModifierPatch
		{
			private static void Prefix(Character __instance, HitData hit)
			{
				if (hit == null)
				{
					return;
				}
				if (__instance is Player)
				{
					float storedModifier = GetStoredModifier(__instance, DataObjects.DamageTakenModifierKey);
					if (storedModifier != 1f)
					{
						hit.ApplyModifier(storedModifier);
					}
				}
				Character attacker = hit.GetAttacker();
				Player val = (Player)(object)((attacker is Player) ? attacker : null);
				if (val != null)
				{
					float storedModifier2 = GetStoredModifier((Character)(object)val, DataObjects.DamageDoneModifierKey);
					if (storedModifier2 != 1f)
					{
						hit.ApplyModifier(storedModifier2);
					}
				}
			}

			private static float GetStoredModifier(Character character, string key)
			{
				if ((Object)(object)character == (Object)null)
				{
					return 1f;
				}
				ZNetView nview = character.m_nview;
				if ((Object)(object)nview == (Object)null || !nview.IsValid())
				{
					return 1f;
				}
				ZDO zDO = nview.GetZDO();
				if (zDO == null)
				{
					return 1f;
				}
				return zDO.GetFloat(key, 1f);
			}
		}
	}
	public static class DeathChoiceEnable
	{
		[HarmonyPatch(typeof(InventoryGui), "Show")]
		public static class ShowDeathChoiceUI
		{
			public static void Postfix(InventoryGui __instance)
			{
				if (ValConfig.UsePrivateKeysForDeathChoice.Value)
				{
					if ((Object)(object)Player.m_localPlayer != (Object)null && Player.m_localPlayer.PlayerHasUniqueKey(DataObjects.DeathChoiceKey))
					{
						return;
					}
				}
				else if ((Object)(object)Player.m_localPlayer != (Object)null && DeathConfigurationData.playerSettings.ContainsKey(Player.m_localPlayer.GetPlayerID()))
				{
					return;
				}
				DeathChoices.DeathChoiceUI.Instance.Show();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		public static class HideDeathChoiceUI
		{
			public static void Postfix(InventoryGui __instance)
			{
				if (DeathChoices.DeathChoiceUI.IsInitialized)
				{
					DeathChoices.DeathChoiceUI.Instance.Hide();
				}
			}
		}
	}
	public class DeathChoices
	{
		public class DeathChoiceUI : MonoBehaviour
		{
			private static DeathChoiceUI _instance;

			private static GameObject DeathChoicePanel;

			private static GameObject ChoicesScrollView;

			private static GameObject ChoicesContent;

			private static GameObject ChoicesContainer;

			private static GameObject manualCloseButton;

			private static GameObject selectChoiceButton;

			private static Text DeathPenaltyDescription;

			private static Text CombatModifiersDescription;

			private static Text XPModifiersDescription;

			private static Text LootModifersDescription;

			private static Text HarvestModifiersDescription;

			private static List<Toggle> difficultyToggles = new List<Toggle>();

			private static ToggleGroup choiceGroup;

			private static string selectedDeathChoice = "none";

			private static bool isChangeMode = false;

			public static DeathChoiceUI Instance
			{
				get
				{
					//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_001d: Expected O, but got Unknown
					if ((Object)(object)_instance == (Object)null)
					{
						GameObject val = new GameObject("DeathlinkDeathChoiceUI");
						Object.DontDestroyOnLoad((Object)val);
						_instance = val.AddComponent<DeathChoiceUI>();
					}
					return _instance;
				}
			}

			public static bool IsInitialized => (Object)(object)_instance != (Object)null;

			public void Awake()
			{
				_instance = this;
				CreateStaticUIObjects();
				SetChoiceList();
			}

			public void Show()
			{
				if ((Object)(object)DeathChoicePanel == (Object)null)
				{
					CreateStaticUIObjects();
					SetChoiceList();
				}
				DeathChoicePanel.SetActive(true);
			}

			public void ShowForChange()
			{
				isChangeMode = true;
				Show();
			}

			public void Hide()
			{
				if ((Object)(object)DeathChoicePanel != (Object)null)
				{
					DeathChoicePanel.SetActive(false);
				}
				isChangeMode = false;
				GUIManager.BlockInput(false);
			}

			public void MakePlayerDeathSelection()
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					Logger.LogWarning("Player not set, ensure the local player is set.");
					return;
				}
				if (selectedDeathChoice == "none")
				{
					Logger.LogWarning("No death type selected");
					return;
				}
				Logger.LogDebug("Player selected death type " + selectedDeathChoice);
				long playerID = Player.m_localPlayer.GetPlayerID();
				if (DeathConfigurationData.playerSettings.ContainsKey(playerID))
				{
					DeathConfigurationData.playerSettings[playerID].DeathChoiceLevel = selectedDeathChoice;
				}
				else
				{
					DeathConfigurationData.playerSettings.Add(playerID, new DataObjects.DeathConfiguration
					{
						DeathChoiceLevel = selectedDeathChoice
					});
				}
				Player.m_localPlayer.PlayerRemoveUniqueKey(DataObjects.DeathChoiceKey);
				Player.m_localPlayer.AddUniqueKeyValue(DataObjects.DeathChoiceKey, selectedDeathChoice);
				if (isChangeMode)
				{
					DeathConfigurationData.IncrementPlayerChangesUsed(Player.m_localPlayer);
				}
				DeathConfigurationData.CheckAndSetPlayerDeathConfig(Player.m_localPlayer);
				DeathConfigurationData.WritePlayerChoices();
				Hide();
			}

			private void SetChoiceList()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				foreach (Transform item in ChoicesContent.transform)
				{
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
				difficultyToggles.Clear();
				int num = -75;
				foreach (KeyValuePair<string, DataObjects.DeathChoiceLevel> entry in DeathConfigurationData.DeathLevels)
				{
					GameObject obj = Object.Instantiate<GameObject>(ChoicesContainer, ChoicesContent.transform);
					Transform val = obj.transform.Find("selecter");
					((Component)val.Find("Label")).GetComponent<Text>().text = entry.Key;
					((Component)obj.transform.Find("ChoiceName")).GetComponent<Text>().text = entry.Value.DisplayName;
					Toggle component = ((Component)val).GetComponent<Toggle>();
					component.group = choiceGroup;
					((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
					{
						if (isOn)
						{
							((Component)DeathPenaltyDescription).GetComponent<Text>().text = entry.Value.GetDeathStyleDescription();
							((Component)CombatModifiersDescription).GetComponent<Text>().text = entry.Value.GetDamageModifierDescription();
							((Component)XPModifiersDescription).GetComponent<Text>().text = entry.Value.GetSkillModiferDescription();
							((Component)LootModifersDescription).GetComponent<Text>().text = entry.Value.GetLootModifiersDescription();
							((Component)HarvestModifiersDescription).GetComponent<Text>().text = entry.Value.GetResourceModiferDescription();
							selectedDeathChoice = entry.Key;
						}
					});
					obj.SetActive(true);
					obj.transform.localPosition = new Vector3
					{
						x = 5f,
						y = num
					};
					difficultyToggles.Add(component);
					num -= 50;
				}
			}

			private void CreateStaticUIObjects()
			{
				//IL_004f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_021b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0225: Expected O, but got Unknown
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_0267: Unknown result type (might be due to invalid IL or missing references)
				//IL_0276: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0292: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0308: Unknown result type (might be due to invalid IL or missing references)
				//IL_030e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0377: Unknown result type (might be due to invalid IL or missing references)
				//IL_0386: Unknown result type (might be due to invalid IL or missing references)
				//IL_0395: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0407: Unknown result type (might be due to invalid IL or missing references)
				//IL_0416: Unknown result type (might be due to invalid IL or missing references)
				//IL_0427: Unknown result type (might be due to invalid IL or missing references)
				//IL_042d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0496: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0517: Unknown result type (might be due to invalid IL or missing references)
				//IL_0526: Unknown result type (might be due to invalid IL or missing references)
				//IL_0535: Unknown result type (might be due to invalid IL or missing references)
				//IL_0546: Unknown result type (might be due to invalid IL or missing references)
				//IL_054c: Unknown result type (might be due to invalid IL or missing references)
				//IL_05b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_05e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_0636: Unknown result type (might be due to invalid IL or missing references)
				//IL_0645: Unknown result type (might be due to invalid IL or missing references)
				//IL_0654: Unknown result type (might be due to invalid IL or missing references)
				//IL_0665: Unknown result type (might be due to invalid IL or missing references)
				//IL_066b: Unknown result type (might be due to invalid IL or missing references)
				//IL_06d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_06e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_06f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0708: Unknown result type (might be due to invalid IL or missing references)
				//IL_070e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0755: Unknown result type (might be due to invalid IL or missing references)
				//IL_0764: Unknown result type (might be due to invalid IL or missing references)
				//IL_0773: Unknown result type (might be due to invalid IL or missing references)
				//IL_0784: Unknown result type (might be due to invalid IL or missing references)
				//IL_078a: Unknown result type (might be due to invalid IL or missing references)
				//IL_07f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0802: Unknown result type (might be due to invalid IL or missing references)
				//IL_0811: Unknown result type (might be due to invalid IL or missing references)
				//IL_0840: Unknown result type (might be due to invalid IL or missing references)
				//IL_084a: Expected O, but got Unknown
				//IL_0874: Unknown result type (might be due to invalid IL or missing references)
				//IL_0879: Unknown result type (might be due to invalid IL or missing references)
				//IL_089e: Unknown result type (might be due to invalid IL or missing references)
				//IL_08bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_08bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_090d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0921: Expected O, but got Unknown
				//IL_0952: Unknown result type (might be due to invalid IL or missing references)
				//IL_09a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_09ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a07: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a16: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a25: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a3b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a41: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)DeathChoicePanel != (Object)null))
				{
					if (GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
					{
						Logger.LogWarning("GUIManager not setup, skipping static object creation.");
						return;
					}
					Logger.LogDebug("Creating static UI");
					DeathChoicePanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 800f, 960f, true);
					DeathChoicePanel.SetActive(false);
					((Object)GUIManager.Instance.CreateText(Localization.instance.Localize("$selection_header"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(50f, 430f), GUIManager.Instance.AveriaSerifBold, 30, GUIManager.Instance.ValheimOrange, true, Color.black, 350f, 40f, false)).name = "DLHeader";
					Text component = GUIManager.Instance.CreateText(Localization.instance.Localize("$selection_description"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 380f), GUIManager.Instance.AveriaSerif, 20, Color.white, true, Color.black, 560f, 60f, false).GetComponent<Text>();
					component.resizeTextForBestFit = true;
					component.resizeTextMaxSize = 20;
					component.alignment = (TextAnchor)4;
					manualCloseButton = GUIManager.Instance.CreateButton(Localization.instance.Localize("$close"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(360f, 430f), 60f, 60f);
					Button component2 = manualCloseButton.GetComponent<Button>();
					((Selectable)component2).interactable = true;
					((UnityEvent)component2.onClick).AddListener(new UnityAction(Hide));
					manualCloseButton.SetActive(true);
					((Object)GUIManager.Instance.CreateText(Localization.instance.Localize("$death_penalty_header"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(100f, 330f), GUIManager.Instance.AveriaSerifBold, 22, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 40f, false)).name = "DeathPenaltyTitle";
					GameObject obj = GUIManager.Instance.CreateText(Localization.instance.Localize("$death_penalty_description"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(147f, 240f), GUIManager.Instance.AveriaSerifBold, 18, Color.white, true, Color.black, 490f, 160f, false);
					((Object)obj).name = "DeathPenaltyDesc";
					DeathPenaltyDescription = obj.GetComponent<Text>();
					DeathPenaltyDescription.resizeTextForBestFit = true;
					DeathPenaltyDescription.resizeTextMaxSize = 18;
					((Object)GUIManager.Instance.CreateText(Localization.instance.Localize("$combat_header"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(100f, 150f), GUIManager.Instance.AveriaSerifBold, 22, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 40f, false)).name = "combatModifiersTitle";
					GameObject obj2 = GUIManager.Instance.CreateText(Localization.instance.Localize("$combat_modifier_description"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(150f, 80f), GUIManager.Instance.AveriaSerifBold, 16, Color.white, true, Color.black, 500f, 100f, false);
					((Object)obj2).name = "combatModifiersDesc";
					CombatModifiersDescription = obj2.GetComponent<Text>();
					CombatModifiersDescription.resizeTextForBestFit = true;
					CombatModifiersDescription.resizeTextMaxSize = 18;
					((Object)GUIManager.Instance.CreateText(Localization.instance.Localize("$xp_header"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(100f, 30f), GUIManager.Instance.AveriaSerifBold, 22, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 40f, false)).name = "xpModifiersTitle";
					GameObject obj3 = GUIManager.Instance.CreateText(Localization.instance.Localize("$xp_mod_description"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(150f, -80f), GUIManager.Instance.AveriaSerifBold, 16, Color.white, true, Color.black, 500f, 200f, false);
					((Object)obj3).name = "xpModifiersDesc";
					XPModifiersDescription = obj3.GetComponent<Text>();
					XPModifiersDescription.resizeTextForBestFit = true;
					XPModifiersDescription.resizeTextMaxSize = 18;
					((Object)GUIManager.Instance.CreateText(Localization.instance.Localize("$loot_header"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(100f, -130f), GUIManager.Instance.AveriaSerifBold, 22, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 40f, false)).name = "lootModifiersTitle";
					GameObject obj4 = GUIManager.Instance.CreateText(Localization.instance.Localize("$loot_modifier_description"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(150f, -240f), GUIManager.Instance.AveriaSerifBold, 16, Color.white, true, Color.black, 500f, 200f, false);
					((Object)obj4).name = "lootModifersDesc";
					LootModifersDescription = obj4.GetComponent<Text>();
					LootModifersDescription.resizeTextForBestFit = true;
					LootModifersDescription.resizeTextMaxSize = 18;
					((Object)GUIManager.Instance.CreateText(Localization.instance.Localize("$harvest_header"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(100f, -260f), GUIManager.Instance.AveriaSerifBold, 22, GUIManager.Instance.ValheimOrange, true, Color.black, 400f, 40f, false)).name = "harvestModifiersTitle";
					GameObject obj5 = GUIManager.Instance.CreateText(Localization.instance.Localize("$harvest_modifier_description"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(150f, -370f), GUIManager.Instance.AveriaSerifBold, 16, Color.white, true, Color.black, 500f, 200f, false);
					((Object)obj5).name = "harvestModifersDesc";
					HarvestModifiersDescription = obj5.GetComponent<Text>();
					HarvestModifiersDescription.resizeTextForBestFit = true;
					HarvestModifiersDescription.resizeTextMaxSize = 18;
					selectChoiceButton = GUIManager.Instance.CreateButton(Localization.instance.Localize("$deathchoice_select"), DeathChoicePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-240f, -290f), 200f, 80f);
					((UnityEvent)selectChoiceButton.GetComponent<Button>().onClick).AddListener(new UnityAction(MakePlayerDeathSelection));
					Logger.LogDebug("Setting up scroll entry");
					ChoicesScrollView = GUIManager.Instance.CreateScrollView(DeathChoicePanel.transform, false, true, 10f, 10f, GUIManager.Instance.ValheimScrollbarHandleColorBlock, Color.grey, 250f, 400f);
					ChoicesScrollView.transform.localPosition = Vector2.op_Implicit(new Vector2
					{
						x = -260f,
						y = -30f
					});
					ChoicesContent = ((Component)ChoicesScrollView.GetComponentInChildren<ContentSizeFitter>()).gameObject;
					ChoicesScrollView.GetComponentInChildren<ScrollRect>().scrollSensitivity = 200f;
					choiceGroup = ChoicesContent.AddComponent<ToggleGroup>();
					Logger.LogDebug("Setting up death choice template entry");
					ChoicesContainer = Object.Instantiate<GameObject>(new GameObject("DeathChoice"), DeathChoicePanel.transform);
					RectTransform obj6 = ChoicesContainer.AddComponent<RectTransform>();
					obj6.SetSizeWithCurrentAnchors((Axis)0, 100f);
					obj6.SetSizeWithCurrentAnchors((Axis)1, 50f);
					((Transform)obj6).position = new Vector3(0f, 0f);
					ChoicesContainer.AddComponent<LayoutElement>().minHeight = 50f;
					ChoicesContainer.SetActive(false);
					GameObject obj7 = GUIManager.Instance.CreateToggle(ChoicesContainer.transform, 40f, 40f);
					obj7.transform.localPosition = Vector2.op_Implicit(new Vector2(10f, 0f));
					((Object)obj7).name = "selecter";
					((Component)obj7.transform.Find("Label")).gameObject.SetActive(false);
					obj7.GetComponent<Toggle>().isOn = false;
					((Object)GUIManager.Instance.CreateText("Name", ChoicesContainer.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(200f, 0f), GUIManager.Instance.AveriaSerifBold, 20, GUIManager.Instance.ValheimYellow, true, Color.black, 350f, 40f, false)).name = "ChoiceName";
				}
			}
		}
	}
	public static class DeathProgressionSkill
	{
		[HarmonyPatch(typeof(Player), "RaiseSkill")]
		public class Deathskill_EXP_Patch
		{
			public static void Postfix(Player __instance)
			{
				//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
				timeSinceGameStart += Time.deltaTime;
				if (lastSkillIncreaseTickTime == 0f)
				{
					lastSkillIncreaseTickTime = timeSinceGameStart + ValConfig.SkillProgressUpdateCheckInterval.Value;
					PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
					_bossKills = playerProfile.m_playerStats.m_stats[(PlayerStatType)85];
					_enemykills = playerProfile.m_playerStats.m_stats[(PlayerStatType)6];
					_piecesBuilt = playerProfile.m_playerStats.m_stats[(PlayerStatType)2];
					_treesChopped = playerProfile.m_playerStats.m_stats[(PlayerStatType)27];
					_mineAmount = playerProfile.m_playerStats.m_stats[(PlayerStatType)38];
					_craftAndUpgrades = playerProfile.m_playerStats.m_stats[(PlayerStatType)1];
				}
				if (timeSinceGameStart > lastSkillIncreaseTickTime)
				{
					lastSkillIncreaseTickTime = timeSinceGameStart + ValConfig.SkillProgressUpdateCheckInterval.Value;
					PlayerProfile playerProfile2 = Game.instance.GetPlayerProfile();
					float num = playerProfile2.m_playerStats.m_stats[(PlayerStatType)85];
					float num2 = playerProfile2.m_playerStats.m_stats[(PlayerStatType)6];
					float num3 = playerProfile2.m_playerStats.m_stats[(PlayerStatType)2];
					float num4 = playerProfile2.m_playerStats.m_stats[(PlayerStatType)27];
					float num5 = playerProfile2.m_playerStats.m_stats[(PlayerStatType)38];
					float num6 = playerProfile2.m_playerStats.m_stats[(PlayerStatType)1];
					float num7 = 0f;
					float num8 = 0f;
					float num9 = 0f;
					float num10 = 0f;
					float num11 = 0f;
					float num12 = 0f;
					if (num > _bossKills || num2 > _enemykills)
					{
						num12 = (num - _bossKills) * ValConfig.SkillGainOnBossKills.Value;
						num11 = (num2 - _enemykills) * ValConfig.SkillGainOnKills.Value;
						Logger.LogDebug($"DeathProgression kill skill bosskill: {num12} kill: {num11}");
						_bossKills = num;
						_enemykills = num2;
					}
					if (num3 > _piecesBuilt)
					{
						num10 = (num3 - _piecesBuilt) * ValConfig.SkillGainOnBuilding.Value;
						Logger.LogDebug($"DeathProgression building skill: {num10}");
						_piecesBuilt = num3;
					}
					if (num4 > _treesChopped || num5 > _mineAmount)
					{
						num9 = (num4 - _treesChopped) * ValConfig.SkillGainOnResourceGathering.Value;
						num8 = (num5 - _mineAmount) * ValConfig.SkillGainOnResourceGathering.Value;
						Logger.LogDebug($"DeathProgression harvesting skill tree_harvest: {num9} mining: {num8}");
						_treesChopped = num4;
						_mineAmount = num5;
					}
					if (num6 > _craftAndUpgrades)
					{
						num7 = (num6 - _craftAndUpgrades) * ValConfig.SkillGainOnCrafts.Value;
						Logger.LogDebug($"DeathProgression crafting skill crafting: {num7}");
						_craftAndUpgrades = num6;
					}
					float num13 = num12 + num11 + num10 + num9 + num8 + num7;
					float num14 = Mathf.Max(0f, (float)Math.Log(__instance.m_timeSinceDeath) / 5f * 0.5f);
					float num15 = num14 * num13;
					if (Deathlink.RustyAlmanacClassesLoaded)
					{
						int num16 = Mathf.RoundToInt(num15 * ValConfig.AlmanacClassesXPGainScale.Value);
						Logger.LogDebug($"Almanac XP Gain {num16}");
						ClassesAPI.AddEXP(num16);
					}
					if (Deathlink.WackyMMOLoaded)
					{
						int num17 = Mathf.RoundToInt(num15 * ValConfig.WackyMMOXPGainScale.Value);
						Logger.LogDebug($"WackyMMO XP Gain {num17}");
						EpicMMOSystem_API.AddExp(num17);
					}
					Logger.LogDebug($"DeathProgression skill bonus from survival (survive time: {__instance.m_timeSinceDeath}) {num14} x {num13} = {num15}");
					((Character)Player.m_localPlayer).RaiseSkill(DeathSkill, num15);
				}
			}
		}

		public static SkillType DeathSkill;

		private static float lastSkillIncreaseTickTime;

		private static float timeSinceGameStart;

		private static float _bossKills;

		private static float _enemykills;

		private static float _piecesBuilt;

		private static float _mineAmount;

		private static float _treesChopped;

		private static float _craftAndUpgrades;

		public static void SetupDeathSkill()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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)
			SkillConfig val = new SkillConfig();
			val.Name = LocalizationManager.Instance.TryTranslate("$death_skill");
			val.Description = LocalizationManager.Instance.TryTranslate("$death_skill_description");
			val.Icon = Deathlink.EmbeddedResourceBundle.LoadAsset<Sprite>("Assets/Custom/Icons/death_skill.png");
			val.Identifier = "midnightsfx.deathskill";
			val.IncreaseStep = 0.1f;
			DeathSkill = SkillManager.Instance.AddSkill(val);
			if (!SkillsChanges.skills_to_avoid_standard_death_penalty.Contains(DeathSkill))
			{
				SkillsChanges.skills_to_avoid_standard_death_penalty.Add(DeathSkill);
			}
		}

		public static float DeathSkillCalculatePercentWithBonus(float bonus = 0f, float min = 0.01f, float max = 1f)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				float skillFactor = ((Character)Player.m_localPlayer).GetSkillFactor(DeathSkill);
				num += skillFactor;
			}
			num += bonus;
			if (num < min)
			{
				num = min;
			}
			if (num > max)
			{
				num = max;
			}
			return num;
		}
	}
	internal static class DeathSavingOptions
	{
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		public static class Player_OnSpawned_Patch
		{
			public static void Postfix(Player __instance)
			{
				if (pendingChoice && !((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					((Character)__instance).Message((MessageType)2, Localization.instance.Localize("$dso_spawn_message"), 0, (Sprite)null);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		public static class ShowSaveChoiceUI
		{
			public static void Postfix()
			{
				if (pendingChoice)
				{
					SaveChoiceUI.Instance.Show(new List<ItemData>(deathItems), totalToSave, maxChoices);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		public static class HideSaveChoiceUI
		{
			public static void Postfix()
			{
				if (SaveChoiceUI.IsInitialized)
				{
					SaveChoiceUI.Instance.Hide();
				}
			}
		}

		public class SaveChoiceUI : MonoBehaviour
		{
			private static SaveChoiceUI _instance;

			private const int GridWidth = 8;

			private static GameObject panel;

			private static Text counterText;

			private static InventoryGrid grid;

			private static RectTransform gridRoot;

			private static Inventory tempInv;

			private static bool selectionWired;

			private static readonly HashSet<ItemData> selected = new HashSet<ItemData>();

			private static int keepBudget = 0;

			private static int pickLimit = 0;

			public static SaveChoiceUI Instance
			{
				get
				{
					//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_001d: Expected O, but got Unknown
					if ((Object)(object)_instance == (Object)null)
					{
						GameObject val = new GameObject("DeathlinkSaveChoiceUI");
						Object.DontDestroyOnLoad((Object)val);
						_instance = val.AddComponent<SaveChoiceUI>();
					}
					return _instance;
				}
			}

			public static bool IsInitialized => (Object)(object)_instance != (Object)null;

			public void Awake()
			{
				_instance = this;
			}

			public void Update()
			{
				if (!((Object)(object)panel == (Object)null) && panel.activeSelf && !((Object)(object)grid == (Object)null) && tempInv != null)
				{
					grid.UpdateInventory(tempInv, (Player)null, (ItemData)null);
				}
			}

			public void Show(List<ItemData> items, int totalKept, int choiceCount)
			{
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				if (EnsurePanel() && EnsureGrid())
				{
					keepBudget = totalKept;
					pickLimit = choiceCount;
					selected.Clear();
					BuildInventory(items);
					grid.UpdateInventory(tempInv, (Player)null, (ItemData)null);
					grid.ResetView();
					string text = $"SaveChoiceUI grid: {tempInv.GetWidth()}x{tempInv.GetHeight()}, ";
					string text2 = $"slot elements={(((Object)(object)gridRoot != (Object)null) ? ((Transform)gridRoot).childCount : (-1))}, ";
					Rect rect = ((RectTransform)((Component)grid).transform).rect;
					Logger.LogDebug(text + text2 + $"gridRect={((Rect)(ref rect)).size}");
					ClearHighlights();
					UpdateCounter();
					panel.SetActive(true);
				}
			}

			public void Hide()
			{
				if ((Object)(object)panel != (Object)null)
				{
					panel.SetActive(false);
				}
			}

			private void Confirm()
			{
				List<ItemData> picked = selected.ToList();
				Hide();
				selected.Clear();
				ApplySelection(picked);
			}

			private bool EnsurePanel()
			{
				//IL_0047: 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_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: 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_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0229: Unknown result type (might be due to invalid IL or missing references)
				//IL_0238: Unknown result type (might be due to invalid IL or missing references)
				//IL_0247: Unknown result type (might be due to invalid IL or missing references)
				//IL_026c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0276: Expected O, but got Unknown
				if ((Object)(object)panel != (Object)null)
				{
					return true;
				}
				if (GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
				{
					Logger.LogWarning("GUIManager not setup, skipping death saving panel creation.");
					return false;
				}
				panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 700f, 640f, true);
				panel.SetActive(false);
				GUIManager.Instance.CreateText(Localization.instance.Localize("$dso_header"), panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 270f), GUIManager.Instance.AveriaSerifBold, 30, GUIManager.Instance.ValheimOrange, true, Color.black, 620f, 40f, false);
				GUIManager.Instance.CreateText(Localization.instance.Localize("$dso_description"), panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 225f), GUIManager.Instance.AveriaSerif, 18, Color.white, true, Color.black, 620f, 50f, false).GetComponent<Text>().alignment = (TextAnchor)4;
				counterText = GUIManager.Instance.CreateText("", panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 180f), GUIManager.Instance.AveriaSerifBold, 18, GUIManager.Instance.ValheimYellow, true, Color.black, 620f, 40f, false).GetComponent<Text>();
				counterText.alignment = (TextAnchor)4;
				((UnityEvent)GUIManager.Instance.CreateButton(Localization.instance.Localize("$dso_confirm"), panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, -270f), 250f, 60f).GetComponent<Button>().onClick).AddListener(new UnityAction(Confirm));
				return true;
			}

			private bool EnsureGrid()
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Expected O, but got Unknown
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)grid != (Object)null)
				{
					return true;
				}
				if ((Object)(object)InventoryGui.instance == (Object)null || (Object)(object)InventoryGui.instance.ContainerGrid == (Object)null)
				{
					Logger.LogWarning("InventoryGui not ready, cannot build death saving grid.");
					return false;
				}
				GameObject val = new GameObject("DL_GridHolder", new Type[1] { typeof(RectTransform) });
				val.transform.SetParent(panel.transform, false);
				RectTransform val2 = (RectTransform)val.transform;
				val2.anchorMin = new Vector2(0.5f, 0.5f);
				val2.anchorMax = new Vector2(0.5f, 0.5f);
				val2.pivot = new Vector2(0.5f, 0.5f);
				val2.sizeDelta = new Vector2(600f, 380f);
				val2.anchoredPosition = new Vector2(0f, -40f);
				GameObject obj = Object.Instantiate<GameObject>(((Component)InventoryGui.instance.ContainerGrid).gameObject, (Transform)(object)val2);
				((Object)obj).name = "DL_SaveGrid";
				obj.SetActive(true);
				RectTransform val3 = (RectTransform)obj.transform;
				((Transform)val3).localScale = Vector3.one;
				((Transform)val3).localRotation = Quaternion.identity;
				val3.anchorMin = Vector2.zero;
				val3.anchorMax = Vector2.one;
				val3.offsetMin = Vector2.zero;
				val3.offsetMax = Vector2.zero;
				grid = obj.GetComponent<InventoryGrid>();
				gridRoot = grid.m_gridRoot;
				if ((Object)(object)gridRoot != (Object)null)
				{
					((Component)gridRoot).gameObject.SetActive(true);
				}
				if ((Object)(object)gridRoot != (Object)null)
				{
					foreach (Transform item in (Transform)gridRoot)
					{
						Object.Destroy((Object)(object)((Component)item).gameObject);
					}
				}
				grid.m_width = 0;
				grid.m_height = 0;
				if (!selectionWired)
				{
					InventoryGrid obj2 = grid;
					obj2.m_onSelected = (Action<InventoryGrid, ItemData, Vector2i, Modifier>)Delegate.Combine(obj2.m_onSelected, (Action<InventoryGrid, ItemData, Vector2i, Modifier>)delegate(InventoryGrid g, ItemData item, Vector2i pos, Modifier mod)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						OnItemClicked(item, pos);
					});
					InventoryGrid obj3 = grid;
					obj3.m_onRightClick = (Action<InventoryGrid, ItemData, Vector2i>)Delegate.Combine(obj3.m_onRightClick, (Action<InventoryGrid, ItemData, Vector2i>)delegate
					{
					});
					selectionWired = true;
				}
				return true;
			}

			private void BuildInventory(List<ItemData> items)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				//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)
				int num = Mathf.Max(1, items.Count);
				int num2 = Mathf.Max(1, Mathf.CeilToInt((float)num / 8f));
				tempInv = new Inventory("DL_SaveChoice", (Sprite)null, 8, num2);
				tempInv.m_inventory.Clear();
				int num3 = 0;
				foreach (ItemData item in items)
				{
					item.m_gridPos = new Vector2i(num3 % 8, num3 / 8);
					tempInv.m_inventory.Add(item);
					num3++;
				}
				tempInv.Changed();
			}

			private void OnItemClicked(ItemData item, Vector2i pos)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				if (item == null)
				{
					return;
				}
				if (selected.Contains(item))
				{
					selected.Remove(item);
					SetHighlight(pos, on: false);
				}
				else
				{
					if (selected.Count >= pickLimit)
					{
						return;
					}
					selected.Add(item);
					SetHighlight(pos, on: true);
				}
				UpdateCounter();
			}

			private void SetHighlight(Vector2i pos, bool on)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)gridRoot == (Object)null)
				{
					return;
				}
				int num = pos.y * 8 + pos.x;
				if (num >= 0 && num < ((Transform)gridRoot).childCount)
				{
					Transform child = ((Transform)gridRoot).GetChild(num);
					Transform val = child.Find("dl_highlight");
					if ((Object)(object)val == (Object)null)
					{
						GameObject val2 = new GameObject("dl_highlight", new Type[2]
						{
							typeof(RectTransform),
							typeof(Image)
						});
						val2.transform.SetParent(child, false);
						RectTransform val3 = (RectTransform)val2.transform;
						val3.anchorMin = Vector2.zero;
						val3.anchorMax = Vector2.one;
						val3.offsetMin = Vector2.zero;
						val3.offsetMax = Vector2.zero;
						Image component = val2.GetComponent<Image>();
						((Graphic)component).color = new Color(1f, 0.82f, 0.2f, 0.4f);
						((Graphic)component).raycastTarget = false;
						val = val2.transform;
					}
					((Component)val).gameObject.SetActive(on);
				}
			}

			private void ClearHighlights()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)gridRoot == (Object)null)
				{
					return;
				}
				foreach (Transform item in (Transform)gridRoot)
				{
					Transform val = item.Find("dl_highlight");
					if ((Object)(object)val != (Object)null)
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
			}

			private void UpdateCounter()
			{
				if (!((Object)(object)counterText == (Object)null))
				{
					string text = string.Format(Localization.instance.Localize("$dso_selected"), selected.Count, pickLimit);
					int num = Mathf.Max(0, keepBudget - selected.Count);
					if (num > 0)
					{
						text = text + "  -  " + string.Format(Localization.instance.Localize("$dso_random_note"), num);
					}
					counterText.text = text;
				}
			}
		}

		private static readonly List<ItemData> deathItems = new List<ItemData>();

		private static int totalToSave = 0;

		private static int maxChoices = 0;

		private static bool pendingChoice = false;

		public static void CaptureDeathChoice(List<ItemData> candidateItems, int totalKept, int choiceCount)
		{
			deathItems.Clear();
			deathItems.AddRange(candidateItems);
			totalToSave = Mathf.Max(0, totalKept);
			maxChoices = Mathf.Clamp(choiceCount, 0, totalToSave);
			pendingChoice = true;
			Logger.LogDebug($"Captured {deathItems.Count} death items for choice, keep {totalToSave}, pick up to {maxChoices}.");
		}

		private static void ApplySelection(List<ItemData> picked)
		{
			Player localPlayer = Player.m_localPlayer;
			List<ItemData> saved = new List<ItemData>();
			if (picked != null)
			{
				foreach (ItemData item in picked)
				{
					if (deathItems.Contains(item) && !saved.Contains(item))
					{
						saved.Add(item);
					}
				}
			}
			if (saved.Count < totalToSave)
			{
				foreach (ItemData item2 in Deathlink.shuffleList(deathItems.Where((ItemData i) => !saved.Contains(i)).ToList()))
				{
					if (saved.Count >= totalToSave)
					{
						break;
					}
					saved.Add(item2);
				}
			}
			if ((Object)(object)localPlayer != (Object)null)
			{
				foreach (ItemData item3 in saved)
				{
					item3.m_equipped = false;
					((Humanoid)localPlayer).m_inventory.AddItem(item3);
				}
				Logger.LogDebug($"Returned {saved.Count} items to the player after death choice.");
			}
			else
			{
				Logger.LogWarning("Local player missing while applying death choice, saved items were lost.");
			}
			deathItems.Clear();
			totalToSave = 0;
			maxChoices = 0;
			pendingChoice = false;
		}
	}
	public static class HarvestModifiers
	{
		[HarmonyPatch(typeof(DropTable), "GetDropList", new Type[] { })]
		public static class ScaleHarvestDropList
		{
			private static void Postfix(List<GameObject> __result)
			{
				if (ScalingActive && HasResourceModifiers())
				{
					ScaleDropListInPlace(__result);
				}
			}
		}

		[HarmonyPatch(typeof(TreeLog), "Destroy")]
		public static class TreeLogHarvestScale
		{
			private static void Prefix(HitData hitData, out bool __state)
			{
				__state = false;
				if (!ScalingActive && ShouldScaleHarvest(hitData))
				{
					ScalingActive = true;
					__state = true;
				}
			}

			private static void Finalizer(TreeLog __instance, bool __state)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (__state)
				{
					ScalingActive = false;
					SpawnHarvestBonusLoot(((Component)__instance).transform.position);
				}
			}
		}

		[HarmonyPatch(typeof(Destructible), "Destroy")]
		public static class DestructibleHarvestScale
		{
			private static void Prefix(Destructible __instance, HitData hit, out bool __state)
			{
				__state = false;
				if (!((Object)(object)__instance.m_spawnWhenDestroyed != (Object)null))
				{
					DropOnDestroyed component = ((Component)__instance).GetComponent<DropOnDestroyed>();
					if (!((Object)(object)component == (Object)null) && component.m_dropWhenDestroyed != null && !component.m_dropWhenDestroyed.IsEmpty() && !ScalingActive && ShouldScaleHarvest(hit))
					{
						ScalingActive = true;
						__state = true;
					}
				}
			}

			private static void Finalizer(Destructible __instance, bool __state)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (__state)
				{
					ScalingActive = false;
					SpawnHarvestBonusLoot(((Component)__instance).transform.position);
				}
			}
		}

		[HarmonyPatch(typeof(MineRock5), "DamageArea")]
		public static class MineRockHarvestScale
		{
			private static void Prefix(HitData hit, out bool __state)
			{
				__state = false;
				if (!ScalingActive && ShouldScaleHarvest(hit))
				{
					ScalingActive = true;
					__state = true;
				}
			}

			private static void Finalizer(MineRock5 __instance, bool __state, bool __result)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				if (__state)
				{
					ScalingActive = false;
					if (__result)
					{
						SpawnHarvestBonusLoot(((Component)__instance).transform.position);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Pickable), "Drop")]
		public static class ScalePickableDrop
		{
			private static bool Prefix(GameObject prefab, ref int stack)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null || !HasResourceModifiers() || (Object)(object)prefab == (Object)null)
				{
					return true;
				}
				float resouceEarlyCache = Deathlink.pcfg().GetResouceEarlyCache(prefab);
				if (resouceEarlyCache == 1f)
				{
					return true;
				}
				int num = ScaleCount(stack, resouceEarlyCache);
				if (num <= 0)
				{
					return false;
				}
				stack = num;
				return true;
			}
		}

		internal static bool ScalingActive;

		private static bool HasResourceModifiers()
		{
			DataObjects.DeathChoiceLevel deathChoiceLevel = Deathlink.pcfg();
			if (deathChoiceLevel.ResourceModifiers != null)
			{
				return deathChoiceLevel.ResourceModifiers.Count > 0;
			}
			return false;
		}

		private static bool ShouldScaleHarvest(HitData hit)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			if (!HasResourceModifiers())
			{
				return false;
			}
			if (hit == null)
			{
				return false;
			}
			return hit.m_attacker == ((Character)Player.m_localPlayer).GetZDOID();
		}

		public static int ScaleCount(int baseCount, float m)
		{
			if (baseCount <= 0)
			{
				return 0;
			}
			float num = (float)baseCount * m;
			int num2 = Mathf.FloorToInt(num);
			float num3 = num - (float)num2;
			if (num3 > 0f && Random.value < num3)
			{
				num2++;
			}
			return num2;
		}

		public static void ScaleDropListInPlace(List<GameObject> drops)
		{
			if (drops == null || drops.Count == 0)
			{
				return;
			}
			Dictionary<GameObject, int> dictionary = new Dictionary<GameObject, int>();
			List<GameObject> list = new List<GameObject>();
			foreach (GameObject drop in drops)
			{
				if (!((Object)(object)drop == (Object)null))
				{
					if (dictionary.TryGetValue(drop, out var value))
					{
						dictionary[drop] = value + 1;
						continue;
					}
					dictionary[drop] = 1;
					list.Add(drop);
				}
			}
			drops.Clear();
			foreach (GameObject item in list)
			{
				float resouceEarlyCache = Deathlink.pcfg().GetResouceEarlyCache(item);
				int num = ((resouceEarlyCache == 1f) ? dictionary[item] : ScaleCount(dictionary[item], resouceEarlyCache));
				if (num != dictionary[item])
				{
					Logger.LogDebug($"Scaling harvest drop {((Object)item).name}: {dictionary[item]} -> {num} (x{resouceEarlyCache})");
				}
				for (int i = 0; i < num; i++)
				{
					drops.Add(item);
				}
			}
		}

		private static void SpawnHarvestBonusLoot(Vector3 position)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			List<KeyValuePair<GameObject, int>> list = Deathlink.pcfg().RollHarvestLoot();
			if (list.Count == 0)
			{
				return;
			}
			foreach (KeyValuePair<GameObject, int> item in list)
			{
				for (int i = 0; i < item.Value; i++)
				{
					Quaternion val = Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f);
					Object.Instantiate<GameObject>(item.Key, position, val);
				}
			}
		}
	}
	internal static class LeaderboardData
	{
		[HarmonyPatch(typeof(Player), "OnDeath")]
		public static class Leaderboard_OnDeath_Patch
		{
			[HarmonyPrefix]
			public static void Prefix(Player __instance)
			{
				if (ValConfig.EnableLeaderboard.Value && !((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					long num = (long)Mathf.Max(0f, __instance.m_timeSinceDeath);
					long longKey = GetLongKey(__instance, DataObjects.LeaderboardDeathCountKey);
					long longKey2 = GetLongKey(__instance, DataObjects.LeaderboardTotalLifeKey);
					long longKey3 = GetLongKey(__instance, DataObjects.LeaderboardLongestLifeKey);
					if (longKey == 0L)
					{
						SetLongKey(__instance, DataObjects.LeaderboardFirstLifeKey, num);
					}
					SetLongKey(__instance, DataObjects.LeaderboardDeathCountKey, longKey + 1);
					SetLongKey(__instance, DataObjects.LeaderboardTotalLifeKey, longKey2 + num);
					if (num > longKey3)
					{
						SetLongKey(__instance, DataObjects.LeaderboardLongestLifeKey, num);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		public static class Leaderboard_Damage_Patch
		{
			[HarmonyPostfix]
			public static void Postfix(Character __instance, HitData hit)
			{
				if (ValConfig.EnableLeaderboard.Value && hit != null && !((Object)(object)Player.m_localPlayer == (Object)null) && !(__instance is Player) && !((Object)(object)hit.GetAttacker() != (Object)(object)Player.m_localPlayer))
				{
					long num = (long)Mathf.Max(0f, hit.GetTotalDamage());
					if (num > 0)
					{
						sessionDamage += num;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		public static class Leaderboard_OnSpawned_Patch
		{
			[HarmonyPostfix]
			public static void Postfix(Player __instance)
			{
				if (!ValConfig.EnableLeaderboard.Value || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || initialReportSent)
				{
					return;
				}
				initialReportSent = true;
				try
				{
					SendLocalSnapshotToServer();
				}
				catch (Exception arg)
				{
					Logger.LogWarning($"Initial leaderboard report failed: {arg}");
				}
			}
		}

		[HarmonyPatch(typeof(Game), "Shutdown")]
		public static class Leaderboard_Shutdown_Patch
		{
			[HarmonyPrefix]
			public static void Prefix()
			{
				if (ValConfig.EnableLeaderboard.Value)
				{
					try
					{
						FlushLocalSnapshotToServer();
					}
					catch (Exception arg)
					{
						Logger.LogWarning($"Leaderboard disconnect flush failed: {arg}");
					}
				}
				initialReportSent = false;
				sessionDamage = 0L;
			}
		}

		public static Dictionary<long, DataObjects.LeaderboardEntry> leaderboard = new Dictionary<long, DataObjects.LeaderboardEntry>();

		private static CustomRPC leaderboardRPC;

		private static long sessionDamage = 0L;

		private static bool initialReportSent = false;

		internal static void Init()
		{
			try
			{
				if (File.Exists(ValConfig.leaderboardPath))
				{
					UpdateLeaderboardFromYaml(File.ReadAllText(ValConfig.leaderboardPath));
				}
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"Failed to load leaderboard data, starting empty. Exception: {arg}");
			}
		}

		public static void Write()
		{
			try
			{
				File.WriteAllText(ValConfig.leaderboardPath, DataObjects.yamlserializer.Serialize((object)leaderboard));
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"Failed to write leaderboard data. Exception: {arg}");
			}
		}

		public static void UpdateLeaderboardFromYaml(string rawyaml)
		{
			if (!string.IsNullOrWhiteSpace(rawyaml))
			{
				Dictionary<long, DataObjects.LeaderboardEntry> dictionary = DataObjects.leaderboardDeserializer.Deserialize<Dictionary<long, DataObjects.LeaderboardEntry>>(rawyaml);
				if (dictionary != null)
				{
					leaderboard = dictionary;
				}
			}
		}

		public static void MergeSnapshot(DataObjects.LeaderboardEntry entry)
		{
			if (entry != null && entry.PlayerID != 0L)
			{
				leaderboard[entry.PlayerID] = entry;
				Write();
			}
		}

		public static void SetupRPC()
		{
			//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
			leaderboardRPC = NetworkManager.Instance.AddRPC("DEATHLK_LB", new CoroutineHandler(OnServerReceiveSnapshot), new CoroutineHandler(OnClientReceiveBoard));
			SynchronizationManager.Instance.AddInitialSynchronization(leaderboardRPC, (Func<ZPackage>)SendFullBoardPackage);
		}

		private static IEnumerator OnServerReceiveSnapshot(long sender, ZPackage package)
		{
			try
			{
				bool num = package.ReadBool();
				string text = package.ReadString();
				MergeSnapshot(DataObjects.leaderboardDeserializer.Deserialize<DataObjects.LeaderboardEntry>(text));
				if (num && leaderboardRPC != null)
				{
					leaderboardRPC.SendPackage(sender, SendFullBoardPackage());
				}
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"Failed to parse leaderboard snapshot from {sender}. Exception: {arg}");
			}
			yield return null;
		}

		private static IEnumerator OnClientReceiveBoard(long sender, ZPackage package)
		{
			string rawyaml = package.ReadString();
			try
			{
				UpdateLeaderboardFromYaml(rawyaml);
				LeaderboardUI.RefreshIfVisible();
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"Failed to parse leaderboard board. Exception: {arg}");
			}
			yield return null;
		}

		private static ZPackage SendFullBoardPackage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(DataObjects.yamlserializer.Serialize((object)leaderboard));
			return val;
		}

		public static void BroadcastFullBoard()
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && leaderboardRPC != null)
			{
				leaderboardRPC.SendPackage(ZNet.instance.m_peers, SendFullBoardPackage());
			}
		}

		public static void SendLocalSnapshotToServer(bool requestBoard = false)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			DataObjects.LeaderboardEntry leaderboardEntry = BuildLocalSnapshot();
			if (leaderboardEntry == null)
			{
				return;
			}
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				MergeSnapshot(leaderboardEntry);
				if (requestBoard)
				{
					LeaderboardUI.RefreshIfVisible();
				}
			}
			else if (leaderboardRPC != null && ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(requestBoard);
				val.Write(DataObjects.yamlserializer.Serialize((object)leaderboardEntry));
				leaderboardRPC.SendPackage(ZRoutedRpc.instance.GetServerPeerID(), val);
			}
		}

		public static void RequestDashboardSync()
		{
			if (!ValConfig.EnableLeaderboard.Value || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			try
			{
				SendLocalSnapshotToServer(requestBoard: true);
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"Leaderboard dashboard sync failed: {arg}");
			}
		}

		public static void FlushLocalSnapshotToServer()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			if (ZNet.instance.IsServer())
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					DataObjects.LeaderboardEntry leaderboardEntry = BuildLocalSnapshot();
					if (leaderboardEntry != null)
					{
						MergeSnapshot(leaderboardEntry);
					}
				}
			}
			else
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null || leaderboardRPC == null)
				{
					return;
				}
				ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
				if (serverPeer == null)
				{
					return;
				}
				DataObjects.LeaderboardEntry leaderboardEntry2 = BuildLocalSnapshot();
				if (leaderboardEntry2 != null)
				{
					ZPackage val = new ZPackage();
					val.Write(false);
					val.Write(DataObjects.yamlserializer.Serialize((object)leaderboardEntry2));
					IEnumerator enumerator = leaderboardRPC.SendPackageRoutine(new List<ZNetPeer> { serverPeer }, val);
					while (enumerator.MoveNext())
					{
					}
				}
			}
		}

		public static DataObjects.LeaderboardEntry BuildLocalSnapshot()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return null;
			}
			PlayerProfile val = (((Object)(object)Game.instance != (Object)null) ? Game.instance.GetPlayerProfile() : null);
			if (val == null || val.m_playerStats == null)
			{
				return null;
			}
			Dictionary<PlayerStatType, float> stats = val.m_playerStats.m_stats;
			long num = GetLongKey(localPlayer, DataObjects.LeaderboardDamageKey);
			if (sessionDamage > 0)
			{
				num += sessionDamage;
				SetLongKey(localPlayer, DataObjects.LeaderboardDamageKey, num);
				sessionDamage = 0L;
			}
			return new DataObjects.LeaderboardEntry
			{
				PlayerID = localPlayer.GetPlayerID(),
				PlayerName = val.GetName(),
				DeathChoice = (DeathConfigurationData.playerDeathConfiguration?.DisplayName ?? ""),
				FirstLifeSeconds = GetLongKey(localPlayer, DataObjects.LeaderboardFirstLifeKey),
				LongestLifeSeconds = GetLongKey(localPlayer, DataObjects.LeaderboardLongestLifeKey),
				TotalLifeSeconds = GetLongKey(localPlayer, DataObjects.LeaderboardTotalLifeKey),
				DeathCount = (int)GetLongKey(localPlayer, DataObjects.LeaderboardDeathCountKey),
				TotalDamage = num,
				BossKills = (int)stats[(PlayerStatType)85],
				TreeChops = (int)stats[(PlayerStatType)27],
				Mines = (int)stats[(PlayerStatType)38],
				CraftsAndBuilds = (int)(stats[(PlayerStatType)1] + stats[(PlayerStatType)2])
			};
		}

		public static IEnumerator SyncLoop()
		{
			yield return (object)new WaitForSeconds(60f);
			while (true)
			{
				float num = Mathf.Max(60f, ValConfig.LeaderboardSyncInterval.Value * 60f);
				if (ValConfig.EnableLeaderboard.Value && (Object)(object)ZNet.instance != (Object)null)
				{
					try
					{
						if (ZNet.instance.IsServer())
						{
							if ((Object)(object)Player.m_localPlayer != (Object)null)
							{
								SendLocalSnapshotToServer();
							}
							BroadcastFullBoard();
						}
						else if ((Object)(object)Player.m_localPlayer != (Object)null)
						{
							SendLocalSnapshotToServer();
						}
					}
					catch (Exception arg)
					{
						Logger.LogWarning($"Leaderboard sync tick failed: {arg}");
					}
				}
				yield return (object)new WaitForSeconds(num);
			}
		}

		private static long GetLongKey(Player player, string key)
		{
			string s = default(string);
			if (player.TryGetUniqueKeyValue(key, ref s) && long.TryParse(s, out var result))
			{
				return result;
			}
			return 0L;
		}

		private static void SetLongKey(Player player, string key, long value)
		{
			player.PlayerRemoveUniqueKey(key);
			player.AddUniqueKeyValue(key, value.ToString());
		}
	}
	public static class LeaderboardUI
	{
		[HarmonyPatch(typeof(TextsDialog), "ShowText", new Type[] { typeof(TextInfo) })]
		public static class TextsDialog_ShowText_Leaderboard_Patch
		{
			public static void Postfix(TextsDialog __instance, TextInfo text)
			{
				bool flag = text != null && text.m_topic == DeathlinkSettingsTopic;
				if (!ValConfig.EnableLeaderboard.Value || !flag)
				{
					if ((Object)(object)leaderboardButton != (Object)null)
					{
						leaderboardButton.SetActive(false);
					}
					return;
				}
				EnsureLeaderboardButton(__instance);
				if ((Object)(object)leaderboardButton != (Object)null)
				{
					leaderboardButton.SetActive(true);
					leaderboardButton.transform.SetAsLastSibling();
				}
			}

			private static void EnsureLeaderboardButton(TextsDialog dialog)
			{
				//IL_005a: 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_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Expected O, but got Unknown
				if ((Object)(object)leaderboardButton != (Object)null)
				{
					return;
				}
				if (GUIManager.Instance == null)
				{
					Logger.LogWarning("GUIManager not setup, skipping leaderboard button creation.");
					return;
				}
				Transform val = ((Component)dialog).transform.Find("Texts_frame/Closebutton");
				if (!((Object)(object)val == (Object)null))
				{
					leaderboardButton = GUIManager.Instance.CreateButton(Localization.instance.Localize("$leaderboard"), val, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-250f, 0f), 200f, 40f);
					((UnityEvent)leaderboardButton.GetComponent<Button>().onClick).AddListener(new UnityAction(Show));
				}
			}
		}

		[HarmonyPatch(typeof(TextsDialog), "OnClose")]
		public static class TextsDialog_OnClose_Leaderboard_Patch
		{
			public static void Postfix()
			{
				Hide();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		public static class InventoryGui_Hide_Leaderboard_Patch
		{
			public static void Postfix()
			{
				Hide();
			}
		}

		private const int ViewSurvival = 0;

		private const int ViewCombat = 1;

		private const int ViewGathering = 2;

		private static GameObject panel;

		private static GameObject content;

		private static readonly List<GameObject> rows = new List<GameObject>();

		private static readonly Text[] headerCols = (Text[])(object)new Text[5];

		private static int currentView = 0;

		private const float RowWidth = 820f;

		private const float RowHeight = 30f;

		private static readonly (float x, float w)[] columns = new(float, float)[5]
		{
			(-310f, 200f),
			(-135f, 150f),
			(25f, 150f),
			(185f, 150f),
			(340f, 140f)
		};

		private static GameObject leaderboardButton;

		public static bool IsVisible
		{
			get
			{
				if ((Object)(object)panel != (Object)null)
				{
					return panel.activeSelf;
				}
				return false;
			}
		}

		private static string DeathlinkSettingsTopic => Localization.instance.Localize("$deathlink_settings");

		public static void Show()
		{
			if (EnsurePanel())
			{
				panel.SetActive(true);
				PopulateView(currentView);
				LeaderboardData.RequestDashboardSync();
			}
		}

		public static void Hide()
		{
			if ((Object)(object)panel != (Object)null)
			{
				panel.SetActive(false);
			}
		}

		public static void RefreshIfVisible()
		{
			if (IsVisible)
			{
				PopulateView(currentView);
			}
		}

		private static bool EnsurePanel()
		{
			//IL_0047: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: 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)
			if ((Object)(object)panel != (Object)null)
			{
				return true;
			}
			if (GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				Logger.LogWarning("GUIManager not setup, skipping leaderboard panel creation.");
				return false;
			}
			panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 900f, 680f, true);
			panel.SetActive(false);
			GUIManager.Instance.CreateText(Localization.instance.Localize("$leaderboard"), panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 290f), GUIManager.Instance.AveriaSerifBold, 30, GUIManager.Instance.ValheimOrange, true, Color.black, 500f, 40f, false);
			((UnityEvent)GUIManager.Instance.CreateButton(Localization.instance.Localize("$close"), panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(420f, 300f), 50f, 50f).GetComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			CreateViewButton("$leaderboard_survival", -230f, 0);
			CreateViewButton("$leaderboard_combat", 0f, 1);
			CreateViewButton("$leaderboard_gathering", 230f, 2);
			for (int i = 0; i < headerCols.Length; i++)
			{
				headerCols[i] = CreateText(panel, new Vector2(columns[i].x, 200f), columns[i].w, "", GUIManager.Instance.ValheimOrange, 18);
			}
			GameObject obj = GUIManager.Instance.CreateScrollView(panel.transform, false, true, 10f, 10f, GUIManager.Instance.ValheimScrollbarHandleColorBlock, Color.grey, 860f, 440f);
			obj.transform.localPosition = Vector2.op_Implicit(new Vector2(0f, -70f));
			obj.GetComponentInChildren<ScrollRect>().scrollSensitivity = 200f;
			content = ((Component)obj.GetComponentInChildren<ContentSizeFitter>()).gameObject;
			VerticalLayoutGroup val = content.GetComponent<VerticalLayoutGroup>();
			if ((Object)(object)val == (Object)null)
			{
				val = content.AddComponent<VerticalLayoutGroup>();
			}
			((LayoutGroup)val).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)val).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)val).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val).spacing = 2f;
			return true;
		}

		private static void CreateViewButton(string locKey, float x, int view)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			((UnityEvent)GUIManager.Instance.CreateButton(Localization.instance.Localize(locKey), panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(x, 240f), 200f, 44f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				PopulateView(view);
			});
		}

		public static void PopulateView(int view)
		{
			currentView = view;
			if (!EnsurePanel())
			{
				return;
			}
			foreach (GameObject row in rows)
			{
				if ((Object)(object)row != (Object)null)
				{
					Object.Destroy((Object)(object)row);
				}
			}
			rows.Clear();
			SetHeaderLabels(view);
			foreach (DataObjects.LeaderboardEntry item in view switch
			{
				1 => from e in LeaderboardData.leaderboard.Values
					orderby e.BossKills descending, e.TotalDamage descending
					select e, 
				2 => LeaderboardData.leaderboard.Values.OrderByDescending((DataObjects.LeaderboardEntry e) => e.TreeChops + e.Mines + e.CraftsAndBuilds), 
				_ => LeaderboardData.leaderboard.Values.OrderByDescending((DataObjects.LeaderboardEntry e) => e.LongestLifeSeconds), 
			})
			{
				rows.Add(CreateRow(item, view));
			}
		}

		private static void SetHeaderLabels(int view)
		{
			string[] array = view switch
			{
				1 => new string[5] { "$lb_col_player", "$lb_col_choice", "$lb_damage", "$lb_bosses", "" }, 
				2 => new string[5] { "$lb_col_player", "$lb_col_choice", "$lb_trees", "$lb_mining", "$lb_crafts" }, 
				_ => new string[5] { "$lb_col_player", "$lb_col_choice", "$lb_first", "$lb_longest", "$lb_average" }, 
			};
			for (int i = 0; i < headerCols.Length; i++)
			{
				headerCols[i].text = (string.IsNullOrEmpty(array[i]) ? "" : Localization.instance.Localize(array[i]));
			}
		}

		private static GameObject CreateRow(DataObjects.LeaderboardEntry entry, int view)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("LBRow", new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			});
			val.transform.SetParent(content.transform, false);
			((RectTransform)val.transform).sizeDelta = new Vector2(820f, 30f);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.preferredHeight = 30f;
			component.minHeight = 30f;
			component.preferredWidth = 820f;
			CreateText(val, new Vector2(columns[0].x, 0f), columns[0].w, entry.PlayerName ?? "", GUIManager.Instance.ValheimYellow, 16);
			CreateText(val, new Vector2(columns[1].x, 0f), columns[1].w, entry.DeathChoice ?? "", Color.white, 16);
			switch (view)
			{
			case 1:
				CreateText(val, new Vector2(columns[2].x, 0f), columns[2].w, Mathf.RoundToInt(entry.TotalDamage).ToString("N0"), Color.white, 16);
				CreateText(val, new Vector2(columns[3].x, 0f), columns[3].w, entry.BossKills.ToString(), Color.white, 16);
				break;
			case 2:
				CreateText(val, new Vector2(columns[2].x, 0f), columns[2].w, entry.TreeChops.ToString(), Color.white, 16);
				CreateText(val, new Vector2(columns[3].x, 0f), columns[3].w, entry.Mines.ToString(), Color.white, 16);
				CreateText(val, new Vector2(columns[4].x, 0f), columns[4].w, entry.CraftsAndBuilds.ToString(), Color.white, 16);
				break;
			default:
				CreateText(val, new Vector2(columns[2].x, 0f), columns[2].w, FormatMinutes(entry.FirstLifeSeconds), Color.white, 16);
				CreateText(val, new Vector2(columns[3].x, 0f), columns[3].w, FormatMinutes(entry.LongestLifeSeconds), Color.white, 16);
				CreateText(val, new Vector2(columns[4].x, 0f), columns[4].w, FormatMinutes(entry.AverageLifeSeconds), Color.white, 16);
				break;
			}
			return val;
		}

		private static Text CreateText(GameObject parent, Vector2 position, float width, string value, Color color, int fontSize)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			Text component = GUIManager.Instance.CreateText(value, parent.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, GUIManager.Instance.AveriaSerifBold, fontSize, color, true, Color.black, width, 30f, false).GetComponent<Text>();
			component.alignment = (TextAnchor)3;
			component.horizontalOverflow = (HorizontalWrapMode)1;
			component.verticalOverflow = (VerticalWrapMode)1;
			return component;
		}

		private static string FormatMinutes(float seconds)
		{
			return $"{Mathf.RoundToInt(seconds / 60f)}m";
		}
	}
	public static class LootModifiers
	{
		[HarmonyPatch(typeof(CharacterDrop))]
		public static class CalculateLootByModifiers
		{
			[HarmonyPostfix]
			[HarmonyPatch("GenerateDropList")]
			private static void Postfix(List<KeyValuePair<GameObject, int>> __result, CharacterDrop __instance)
			{
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				if (!__instance.m_character.m_localPlayerHasHit || Deathlink.pcfg().DeathLootModifiers == null || Deathlink.pcfg().DeathLootModifiers.Count == 0)
				{
					return;
				}
				List<KeyValuePair<GameObject, int>> list = new List<KeyValuePair<GameObject, int>>();
				foreach (KeyValuePair<GameObject, int> item in __result)
				{
					float resouceEarlyCache = Deathlink.pcfg().GetResouceEarlyCache(((Object)item.Key).name);
					if (resouceEarlyCache == 1f)
					{
						list.Add(item);
						continue;
					}
					int num = Mathf.RoundToInt((float)item.Value * resouceEarlyCache);
					if (num >= 1)
					{
						list.Add(new KeyValuePair<GameObject, int>(item.Key, num));
					}
				}
				List<KeyValuePair<GameObject, int>> list2 = Deathlink.pcfg().RollKillLoot();
				if (list2.Count > 0)
				{
					foreach (KeyValuePair<GameObject, int> item2 in list2)
					{
						for (int i = 0; i < item2.Value; i++)
						{
							Object.Instantiate<GameObject>(item2.Key, ((Component)__instance).transform.position, Quaternion.identity);
						}
					}
				}
				__result.Clear();
				__result.AddRange(list);
			}
		}
	}
	public static class SkillsChanges
	{
		[HarmonyPatch(typeof(Skills), "OnDeath")]
		private static class OnDeath_Patch
		{
			private static bool Prefix(Skills __instance)
			{
				if (((Character)__instance.m_player).m_seman.HaveStatusEffect(SEMan.s_statusEffectSoftDeath))
				{
					return false;
				}
				if (Deathlink.pcfg().DeathStyle.skillLossOnDeath)
				{
					float num = Mathf.Lerp(Deathlink.pcfg().DeathStyle.maxSkillLossPercentage, Deathlink.pcfg().DeathStyle.minSkillLossPercentage, DeathProgressionSkill.DeathSkillCalculatePercentWithBonus());
					Logger.LogDebug($"{num}");
					LowerConfigurableSkills(__instance, num);
				}
				return false;
			}

			private static void LowerConfigurableSkills(Skills skills, float factor)
			{
				//IL_001d: 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)
				foreach (KeyValuePair<SkillType, Skill> skillDatum in skills.m_skillData)
				{
					if (skills_to_avoid_standard_death_penalty.Contains(skillDatum.Key))
					{
						Logger.LogDebug($"Skipping lowering skill {skillDatum.Key} current level: {skillDatum.Value.m_level}");
						continue;
					}
					float num = skillDatum.Value.m_level * factor;
					Skill value = skillDatum.Value;
					value.m_level -= num;
					skillDatum.Value.m_accumulator = 0f;
				}
				if (Deathlink.RustyAlmanacClassesLoaded && ValConfig.EnableAlmanacClassesXPLossOnDeath.Value)
				{
					int level = ClassesAPI.GetLevel();
					int num2 = Mathf.RoundToInt((float)level * factor * 500f * ValConfig.AlmanacClassesXPLossScale.Value) * -1;
					Logger.LogDebug($"Almanac (lvl {level}) XP Loss: {num2}");
					ClassesAPI.AddEXP(num2);
				}
				if (Deathlink.WackyMMOLoaded && ValConfig.EnableWackyMMOXPLossOnDeath.Value)
				{
					int level2 = EpicMMOSystem_API.GetLevel();
					int num3 = Mathf.RoundToInt((float)level2 * factor * 500f * ValConfig.WackyMMOXPLossScale.Value) * -1;
					Logger.LogDebug($"WackyMMO (lvl {level2}) XP Loss: {num3}");
					EpicMMOSystem_API.AddExp(num3);
				}
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, "$msg_skills_lowered", 0, (Sprite)null);
				}
			}
		}

		[HarmonyPatch(typeof(Skills), "RaiseSkill")]
		private static class SkillRaisePatch
		{
			private static void Prefix(Skills __instance, SkillType skillType, ref float factor)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				float skillBonusLazyCache = Deathlink.pcfg().GetSkillBonusLazyCache(skillType);
				Logger.LogDebug($"{skillType} skillGain Modified {skillBonusLazyCache}");
				if (skillBonusLazyCache != 0f)
				{
					factor *= skillBonusLazyCache;
				}
			}
		}

		public static List<SkillType> skills_to_avoid_standard_death_penalty = new List<SkillType>();
	}
	public static class OnDeathChanges
	{
		[HarmonyPatch(typeof(Player))]
		public static class OnDeath_Tombstone_Patch
		{
			[HarmonyTranspiler]
			[HarmonyPatch("OnDeath")]
			private static IEnumerable<CodeInstruction> ConstructorTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Expected O, but got Unknown
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, generator);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Player), "CreateTombStone", (Type[])null, (Type[])null), (string)null)
				}).Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<Player>>((Action<Player>)ModifyDeath) })
					.CreateLabelOffset(out var label, 4)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Br, (object)label)
					})
					.ThrowIfNotMatch("Unable to patch Deathlink player death changes.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			private static void ModifyDeath(Player __instance)
			{
				TombstoneOnDeath(__instance);
				FoodLossOnDeath(__instance);
			}

			public static void FoodLossOnDeath(Player instance)
			{
				if (!Deathlink.pcfg().DeathStyle.foodLossOnDeath)
				{
					return;
				}
				if (Deathlink.pcfg().DeathStyle.foodLossUsesDeathlink && instance.m_foods.Count > 0)
				{
					float num = DeathProgressionSkill.DeathSkillCalculatePercentWithBonus();
					if (num >= 0.9f)
					{
						return;
					}
					if (num >= 0.6f && num < 0.9f)
					{
						instance.m_foods.Remove(instance.m_foods[0]);
					}
					else if (num > 0.3f && num < 0.6f)
					{
						instance.m_foods.Remove(instance.m_foods[0]);
						if (instance.m_foods.Count > 0)
						{
							instance.m_foods.Remove(instance.m_foods[0]);
						}
					}
					else
					{
						instance.m_foods.Clear();
					}
				}
				else
				{
					instance.m_foods.Clear();
				}
			}

			public static void TombstoneOnDeath(Player instance)
			{
				//IL_042d: Unknown result type (might be due to invalid IL or missing references)
				//IL_043d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0577: Unknown result type (might be due to invalid IL or missing references)
				//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
				List<ItemData> allItems = ((Humanoid)instance).m_inventory.GetAllItems();
				List<ItemData> list = new List<ItemData>();
				List<ItemData> list2 = new List<ItemData>();
				Inventory inventory = ((Humanoid)instance).m_inventory;
				Dictionary<DataObjects.ItemResults, List<ItemData>> dictionary = new Dictionary<DataObjects.ItemResults, List<ItemData>>();
				string[] source = ValConfig.ItemsNotSkillChecked.Value.Split(new char[1] { ',' });
				foreach (ItemData item in allItems)
				{
					if ((Object)(object)item.m_dropPrefab != (Object)null && source.Contains(((Object)item.m_dropPrefab).name))
					{
						list2.Add(item);
					}
					else
					{
						list.Add(item);
					}
				}
				switch (Deathlink.pcfg().DeathStyle.itemLossStyle)
				{
				case DataObjects.ItemLossStyle.None:
					Logger.LogDebug("No items destroyed on death.");
					dictionary.SafeInsertOrAppend(DataObjects.ItemResults.ItemSaved, list);
					break;
				case DataObjects.ItemLossStyle.DestroyNonWeaponArmor:
					Logger.LogDebug("Destroying non Equipment items.");
					dictionary.SafeInsertOrAppend(DataObjects.ItemResults.ItemLost, list.GetNotEquipment());
					dictionary.SafeInsertOrAppend(DataObjects.ItemResults.EquipmentSaved, list.GetEquipment());
					foreach (ItemData item2 in list.GetNotEquipment())
					{
						((Humanoid)instance).m_inventory.RemoveItem(item2);
					}
					if (!Deathlink.AzuEPILoaded)
					{
						break;
					}
					Logger.LogDebug("AzuEPI| Removing non-equipment items from quickslots.");
					foreach (ItemData quickSlotsItem in API.GetQuickSlotsItems())
					{
						if (!quickSlotsItem.IsEquipment())
						{
							((Humanoid)instance).m_inventory.RemoveItem(quickSlotsItem);
							dictionary.SafeInsertOrAppend(DataObjects.ItemResults.ItemLost, quickSlotsItem);
						}
						else
						{
							dictionary.SafeInsertOrAppend(DataObjects.ItemResults.EquipmentSaved, quickSlotsItem);
						}
					}
					break;
				case DataObjects.ItemLossStyle.DestroyAll:
					Logger.LogDebug("Destroying all non skill checked items.");
					dictionary.SafeInsertOrAppend(DataObjects.ItemResults.ItemLost, list);
					foreach (ItemData item3 in list)
					{
						((Humanoid)instance).m_inventory.RemoveItem(item3);
					}
					if (Deathlink.AzuEPILoaded)
					{
						Logger.LogDebug("AzuEPI| Destroying quickslot items.");
						dictionary.SafeInsertOrAppend(DataObjects.ItemResults.ItemLost, API.GetQuickSlotsItems());
						API.GetQuickSlotsItems().ForEach(delegate(ItemData item)
						{
							((Humanoid)instance).m_inventory.RemoveItem(item);
						});
					}
					break;
				case DataObjects.ItemLossStyle.DeathlinkBased:
				{
					float deathskillbonus = DeathProgressionSkill.DeathSkillCalculatePercentWithBonus();
					int num = CalculateItemsSavable(deathskillbonus);
					int num2 = Mathf.Clamp(CalculateItemChoiceCount(deathskillbonus), 0, num);
					if (Deathlink.pcfg().DeathStyle.EnableItemSavingChoices && num2 > 0 && list.Count > num)
					{
						Logger.LogDebug($"Deferring item saving to respawn choice. keep {num}, pick {num2}, pool {list.Count}");
						foreach (ItemData item4 in list)
						{
							((Humanoid)instance).m_inventory.RemoveItem(item4);
						}
						DeathSavingOptions.CaptureDeathChoice(list, num, num2);
					}
					else
					{
						Logger.LogDebug("Destroying random items based on deathlink skill");
						dictionary = DetermineItemResultsByDeathlink(instance, list);
						dictionary[DataObjects.ItemResults.EquipmentLost].ForEach(delegate(ItemData item)
						{
							((Humanoid)instance).m_inventory.RemoveItem(item);
						});
						dictionary[DataObjects.ItemResults.ItemLost].ForEach(delegate(ItemData item)
						{
							((Humanoid)instance).m_inventory.RemoveItem(item);
						});
					}
					break;
				}
				}
				if (Deathlink.pcfg().DeathStyle.nonSkillCheckedItemAction == DataObjects.NonSkillCheckedItemAction.Destroy)
				{
					Logger.LogDebug("Non skill checked being destroyed.");
					dictionary.SafeInsertOrAppend(DataObjects.ItemResults.ItemLost, list2);
				}
				if (Deathlink.pcfg().DeathStyle.nonSkillCheckedItemAction == DataObjects.NonSkillCheckedItemAction.Save)
				{
					Logger.LogDebug("Non skill checked items being left on player.");
				}
				if ((!dictionary.ContainsKey(DataObjects.ItemResults.EquipmentSaved) || dictionary[DataObjects.ItemResults.EquipmentSaved].Count <= 0) && (!dictionary.ContainsKey(DataObjects.ItemResults.ItemSaved) || dictionary[DataObjects.ItemResults.ItemSaved].Count <= 0) && (Deathlink.pcfg().DeathStyle.nonSkillCheckedItemAction != DataObjects.NonSkillCheckedItemAction.Tombstone || list2.Count() <= 0))
				{
					return;
				}
				Logger.LogDebug("Tombstone needed");
				GameObject obj = Object.Instantiate<GameObject>(instance.m_tombstone, ((Character)instance).GetCenterPoint(), ((Component)instance).transform.rotation);
				Inventory inventory2 = obj.GetComponent<Container>().GetInventory();
				if (Deathlink.pcfg().DeathStyle.itemSavedStyle == DataObjects.ItemSavedStyle.Tombstone)
				{
					Logger.LogDebug("Adding saved items to tombstone.");
					if (dictionary.ContainsKey(DataObjects.ItemResults.EquipmentSaved) && dictionary[DataObjects.ItemResults.EquipmentSaved].Count > 0)
					{
						AddItemsToTombstone(inventory2, dictionary[DataObjects.ItemResults.EquipmentSaved]);
						dictionary[DataObjects.ItemResults.EquipmentSaved].ForEach(delegate(ItemData item)
						{
							((Humanoid)instance).m_inventory.RemoveItem(item);
						});
					}
					if (dictionary.ContainsKey(DataObjects.ItemResults.ItemSaved) && dictionary[DataObjects.ItemResults.ItemSaved].Count > 0)
					{
						AddItemsToTombstone(inventory2, dictionary[DataObjects.ItemResults.ItemSaved]);
						dictionary[DataObjects.ItemResults.ItemSaved].ForEach(delegate(ItemData item)
						{
							((Humanoid)instance).m_inventory.RemoveItem(item);
						});
					}
				}
				if (Deathlink.pcfg().DeathStyle.nonSkillCheckedItemAction == DataObjects.NonSkillCheckedItemAction.Tombstone)
				{
					Logger.LogDebug("Adding saved non-skill checked items to tombstone.");
					AddItemsToTombstone(inventory2, list2);
					list2.ForEach(delegate(ItemData item)
					{
						((Humanoid)instance).m_inventory.RemoveItem(item);
					});
				}
				TombStone component = obj.GetComponent<TombStone>();
				PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
				string name = playerProfile.GetName();
				long playerID = playerProfile.GetPlayerID();
				component.Setup(name, playerID);
				inventory.Changed();
				if (ValConfig.ShowDeathMapMarker.Value)
				{
					Minimap.instance.AddPin(((Component)instance).transform.position, (PinType)4, $"$hud_mapday {EnvMan.instance.GetDay(ZNet.instance.GetTimeSeconds())}", true, false, 0L, default(PlatformUserID));
				}
			}

			public static void AddItemsToTombstone(Inventory tombstone, List<ItemData> transferItems)
			{
				int num = Mathf.RoundToInt(Mathf.Sqrt((float)transferItems.Count())) + 1;
				tombstone.m_width += num;
				tombstone.m_height += num;
				foreach (ItemData transferItem in transferItems)
				{
					tombstone.m_inventory.Add(transferItem);
				}
				tombstone.Changed();
			}

			internal static int CalculateItemsToKeep(float deathskillbonus)
			{
				return Mathf.RoundToInt((float)(Deathlink.pcfg().DeathStyle.maxItemsKept - Deathlink.pcfg().DeathStyle.minItemsKept) * deathskillbonus + (float)Deathlink.pcfg().DeathStyle.minItemsKept);
			}

			internal static int CalculateEquipmentSavable(float deathskillbonus)
			{
				return Mathf.RoundToInt((float)(Deathlink.pcfg().DeathStyle.maxEquipmentKept - Deathlink.pcfg().DeathStyle.minEquipmentKept) * deathskillbonus + (float)Deathlink.pcfg().DeathStyle.minEquipmentKept);
			}

			internal static int CalculateItemsSavable(float deathskillbonus)
			{
				return CalculateItemsToKeep(deathskillbonus) + CalculateEquipmentSavable(deathskillbonus);
			}

			internal static int CalculateItemChoiceCount(float deathskillbonus)
			{
				return Mathf.RoundToInt((float)(Deathlink.pcfg().DeathStyle.maxItemsKeptChoices - Deathlink.pcfg().DeathStyle.minItemsKeptChoices) * deathskillbonus + (float)Deathlink.pcfg().DeathStyle.minItemsKeptChoices);
			}

			internal static Dictionary<DataObjects.ItemResults, List<ItemData>> DetermineItemResultsByDeathlink(Player player, List<ItemData> playerItemsWithoutNonSkillCheckedItems)
			{
				float deathskillbonus = DeathProgressionSkill.DeathSkillCalculatePercentWithBonus();
				int num = CalculateItemsToKeep(deathskillbonus);
				int num2 = CalculateEquipmentSavable(deathskillbonus);
				int remainingsaves = num + num2;
				Dictionary<DataObjects.ItemResults, List<ItemData>> dictionary = new Dictionary<DataObjects.ItemResults, List<ItemData>>
				{
					{
						DataObjects.ItemResults.EquipmentSaved,
						new List<ItemData>()
					},
					{
						DataObjects.ItemResults.EquipmentLost,
						new List<ItemData>()
					},
					{
						DataObjects.ItemResults.ItemSaved,
						new List<ItemData>()
					},
					{
						DataObjects.ItemResults.ItemLost,
						new List<ItemData>()
					}
				};
				int equipment_saved_count = 0;
				foreach (ItemData item in Deathlink.shuffleList(playerItemsWithoutNonSkillCheckedItems.GetEquipment()))
				{
					if (remainingsaves > 0)
					{
						if (RemoveEquipmentByStyle(equipment_saved_count, num2, item, remainingsaves, out remainingsaves, out equipment_saved_count))
						{
							Logger.LogDebug("Save: " + item.m_shared.m_name);
							dictionary[DataObjects.ItemResults.EquipmentSaved].Add(item);
						}
						else
						{
							Logger.LogDebug("Remove by style: " + item.m_shared.m_name);
							dictionary[DataObjects.ItemResults.EquipmentLost].Add(item);
						}
					}
					else
					{
						Logger.LogDebug("Save limit reached, removing: " + item.m_shared.m_name);
						dictionary[DataObjects.ItemResults.EquipmentLost].Add(item);
					}
				}
				if (Deathlink.AzuEPILoaded)
				{
					foreach (ItemData quickSlotsItem in API.GetQuickSlotsItems())
					{
						if (quickSlotsItem.IsEquipment() && remainingsaves > 0)
						{
							remainingsaves--;
							num--;
							dictionary[DataObjects.ItemResults.EquipmentSaved].Add(quickSlotsItem);
						}
						else if (remainingsaves > 0)
						{
							remainingsaves--;
							num--;
							dictionary[DataObjects.ItemResults.ItemSaved].Add(quickSlotsItem);
						}
						else
						{
							dictionary[DataObjects.ItemResults.ItemLost].Add(quickSlotsItem);
						}
					}
				}
				List<ItemData> list = Deathlink.shuffleList(playerItemsWithoutNonSkillCheckedItems.GetNotEquipment());
				if (remainingsaves > 0)
				{
					foreach (ItemData item2 in list)
					{
						if (remainingsaves > 0 && num > 0)
						{
							Logger.LogDebug("NonEq| Saving: " + item2.m_shared.m_name);
							dictionary[DataObjects.ItemResults.ItemSaved].Add(item2);
							remainingsaves--;
							num--;
						}
						else
						{
							Logger.LogDebug("NonEq| Removing: " + item2.m_shared.m_name);
							dictionary[DataObjects.ItemResults.ItemLost].Add(item2);
						}
					}
				}
				else
				{
					Logger.LogDebug($"NonEq| Removing: {list.Count} due to no saves remaining.");
					foreach (ItemData item3 in list)
					{
						dictionary[DataObjects.ItemResults.ItemLost].Add(item3);
					}
				}
				return dictionary;
			}

			internal static bool RemoveEquipmentByStyle(int equipment_saved, int max_equipment_savable, ItemData equipment, int numberOfItemsSavable, out int remainingsaves, out int equipment_saved_count)
			{
				equipment_saved_count = equipment_saved;
				remainingsaves = numberOfItemsSavable;
				if (numberOfItemsSavable <= 0)
				{
					return false;
				}
				if (equipment_saved >= max_equipment_savable)
				{
					Logger.LogDebug($"Max equipment retained ({max_equipment_savable}) reached, removing {((Object)equipment.m_dropPrefab).name}");
					return false;
				}
				Logger.LogDebug($"Saving equipment remaining savable?({numberOfItemsSavable}) {((Object)equipment.m_dropPrefab).name}");
				equipment_saved_count = equipment_saved + 1;
				remainingsaves = numberOfItemsSavable - 1;
				return true;
			}
		}
	}
}
namespace Deathlink.Common
{
	internal static class TerminalCommands
	{
		internal class ResetPlayerDeathChoice : ConsoleCommand
		{
			public override string Name => "DL-RESET-CHOICE";

			public override bool IsNetwork => true;

			public override string Help => "Format: [steamID|playerName] resets the deathlink choice for the target player. Accepts a platform Steam ID or a case-insensitive player name.";

			public override void Run(string[] args)
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: 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_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Expected O, but got Unknown
				if (!SynchronizationManager.Instance.PlayerIsAdmin)
				{
					Logger.LogWarning("You are not an admin, and not allowed to run this command.");
					return;
				}
				if (args.Length < 1)
				{
					Logger.LogInfo("Player Steam ID or name required");
					return;
				}
				string text = args[0];
				foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
				{
					string text2 = player.m_userInfo.m_id.m_userID.ToString();
					string displayName = player.m_userInfo.m_displayName;
					bool flag = text2 == text;
					bool flag2 = string.Equals(displayName, text, StringComparison.OrdinalIgnoreCase);
					bool flag3 = string.Equals(player.m_name, text, StringComparison.OrdinalIgnoreCase);
					Logger.LogDebug("Checking Player " + displayName + " (platformID: " + text2 + ", playerName: " + player.m_name + ") against '" + text + "'");
					if (flag || flag2 || flag3)
					{
						Logger.LogInfo("Matched player " + displayName + " (platformID: " + text2 + ") for reset command.");
						ZPackage val = new ZPackage();
						val.Write(text2);
						Logger.LogDebug("Requesting server reset of player saved Deathlink choice");
						ValConfig.resetChoiceRPC.SendPackage(ZRoutedRpc.instance.GetServerPeerID(), val);
					}
				}
			}
		}

		internal static void AddCommands()
		{
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ResetPlayerDeathChoice());
		}
	}
	public class DataObjects
	{
		public enum ItemLossStyle
		{
			None,
			DestroyNonWeaponArmor,
			DeathlinkBased,
			DestroyAll
		}

		public enum ItemResults
		{
			EquipmentSaved,
			EquipmentLost,
			ItemSaved,
			ItemLost
		}

		public enum ItemSavedStyle
		{
			OnCharacter,
			Tombstone
		}

		public enum ResourceGainTypes
		{
			Kills,
			Harvesting
		}

		public enum NonSkillCheckedItemAction
		{
			Destroy,
			Tombstone,
			Save
		}

		public class DeathProgressionDetails
		{
			public bool foodLossOnDeath = true;

			public bool foodLossUsesDeathlink = true;

			public int minItemsKept;

			public int maxItemsKept;

			public int minEquipmentKept;

			public int maxEquipmentKept;

			public int minItemsKeptChoices;

			public int maxItemsKeptChoices;

			public bool skillLossOnDeath = true;

			public float maxSkillLossPercentage;

			public float minSkillLossPercentage;

			public ItemLossStyle itemLossStyle;

			public ItemSavedStyle itemSavedStyle;

			public bool EnableItemSavingChoices = true;

			public NonSkillCheckedItemAction nonSkillCheckedItemAction = NonSkillCheckedItemAction.Tombstone;
		}

		public class DeathResourceModifier
		{
			public bool skillInfluence { get; set; } = true;

			public List<string> prefabs { get; set; }

			public float bonusModifer { get; set; }

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

		public class DeathSkillModifier
		{
			public bool skillInfluence { get; set; } = true;

			public SkillType skill { get; set; }

			public float bonusModifer { get; set; }
		}

		public class DeathLootModifier
		{
			private bool skillInfluence { get; set; } = true;

			public string prefab { get; set; }

			public float chance { get; set; }

			public int amount { get; set; } = 1;

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

		public class DeathChoiceLevel
		{
			private Dictionary<SkillType, float> CalculatedSkillMods = new Dictionary<SkillType, float>();

			private Dictionary<string, float> CalculatedResourceMods = new Dictionary<string, float>();

			private bool CalculatedResourceModsCached;

			private Dictionary<GameObject, Tuple<float, int>> KillLootModifiers = new Dictionary<GameObject, Tuple<float, int>>();

			private bool CalculatedKillLootModifiersCached;

			private Dictionary<GameObject, Tuple<float, int>> ResourceLootModifiers = new Dictionary<GameObject, Tuple<float, int>>();

			private bool CalculatedHarvestLootModifiersCached;

			public string DisplayName { get; set; }

			public DeathProgressionDetails DeathStyle { get; set; } = new DeathProgressionDetails();

			public float DeathSkillRate { get; set; } = 1f;

			public float DamageTakenModifier { get; set; } = 1f;

			public float DamageDoneModifier { get; set; } = 1f;

			public Dictionary<string, DeathResourceModifier> ResourceModifiers { get; set; }

			public Dictionary<string, DeathSkillModifier> SkillModifiers { get; set; }

			public Dictionary<string, DeathLootModifier> DeathLootModifiers { get; set; }

			public List<KeyValuePair<GameObject, int>> RollKillLoot()
			{
				if (!CalculatedKillLootModifiersCached)
				{
					if (DeathLootModifiers != null && DeathLootModifiers.Count > 0)
					{
						foreach (KeyValuePair<string, DeathLootModifier> deathLootModifier in DeathLootModifiers)
						{
							if (!deathLootModifier.Value.bonusActions.Contains(ResourceGainTypes.Kills))
							{
								continue;
							}
							if (string.IsNullOrEmpty(deathLootModifier.Value.prefab))
							{
								Logger.LogWarning("Kill loot modifier '" + deathLootModifier.Key + "' has no prefab set, it will be skipped.");
								continue;
							}
							GameObject prefab = PrefabManager.Instance.GetPrefab(deathLootModifier.Value.prefab);
							if ((Object)(object)prefab == (Object)null)
							{
								Logger.LogWarning("Could not find prefab " + deathLootModifier.Value.prefab + " while building kill loot table, it will be skipped.");
							}
							else
							{
								KillLootModifiers.Add(prefab, new Tuple<float, int>(deathLootModifier.Value.chance, deathLootModifier.Value.amount));
							}
						}
					}
					CalculatedKillLootModifiersCached = true;
				}
				List<KeyValuePair<GameObject, int>> list = new List<KeyValuePair<GameObject, int>>();
				foreach (KeyValuePair<GameObject, Tuple<float, int>> killLootModifier in KillLootModifiers)
				{
					float value = Random.value;
					Logger.LogDebug($"Rolling chance loot for: {((Object)killLootModifier.Key.gameObject).name} {value} < {killLootModifier.Value.Item1}");
					if (value < killLootModifier.Value.Item1)
					{
						list.Add(new KeyValuePair<GameObject, int>(killLootModifier.Key, killLootModifier.Value.Item2));
					}
				}
				return list;
			}

			public List<KeyValuePair<GameObject, int>> RollHarvestLoot()
			{
				if (!CalculatedHarvestLootModifiersCached)
				{
					if (DeathLootModifiers != null && DeathLootModifiers.Count > 0)
					{
						foreach (KeyValuePair<string, DeathLootModifier> deathLootModifier in DeathLootModifiers)
						{
							if (!deathLootModifier.Value.bonusActions.Contains(ResourceGainTypes.Harvesting))
							{
								continue;
							}
							if (string.IsNullOrEmpty(deathLootModifier.Value.prefab))
							{
								Logger.LogWarning("Harvest loot modifier '" + deathLootModifier.Key + "' has no prefab set, it will be skipped.");
								continue;
							}
							GameObject prefab = PrefabManager.Instance.GetPrefab(deathLootModifier.Value.prefab);
							if ((Object)(object)prefab == (Object)null)
							{
								Logger.LogWarning("Could not find prefab " + deathLootModifier.Value.prefab + " while building harvest loot table, it will be skipped.");
							}
							else
							{
								ResourceLootModifiers.Add(prefab, new Tuple<float, int>(deathLootModifier.Value.chance, deathLootModifier.Value.amount));
							}
						}
					}
					CalculatedHarvestLootModifiersCached = true;
				}
				List<KeyValuePair<GameObject, int>> list = new List<KeyValuePair<GameObject, int>>();
				foreach (KeyValuePair<GameObject, Tuple<float, int>> resourceLootModifier in ResourceLootModifiers)
				{
					if (Random.value < resourceLootModifier.Value.Item1)
					{
						list.Add(new KeyValuePair<GameObject, int>(resourceLootModifier.Key, resourceLootModifier.Value.Item2));
					}
				}
				return list;
			}

			public float GetResouceEarlyCache(string prefab)
			{
				if (!CalculatedResourceModsCached)
				{
					Logger.LogDebug("Building cache entry for " + prefab);
					if (ResourceModifiers != null)
					{
						foreach (KeyValuePair<string, DeathResourceModifier> resourceModifier in ResourceModifiers)
						{
							if (resourceModifier.Value.prefabs == null)
							{
								continue;
							}
							foreach (string prefab2 in resourceModifier.Value.prefabs)
							{
								Logger.LogDebug($"Building cache entry for {prefab2} - {resourceModifier.Value.bonusModifer}");
								CalculatedResourceMods.Add(prefab2, resourceModifier.Value.bonusModifer);
							}
						}
					}
					CalculatedResourceModsCached = true;
				}
				if (CalculatedResourceMods.ContainsKey(prefab))
				{
					return CalculatedResourceMods[prefab];
				}
				return 1f;
			}

			public float GetResouceEarlyCache(GameObject prefab)
			{
				if ((Object)(object)prefab == (Object)null)
				{
					return 1f;
				}
				return GetResouceEarlyCache(((Object)prefab).name);
			}

			public float GetSkillBonusLazyCache(SkillType skilltype)
			{
				//IL_0006: 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_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Invalid comparison between Unknown and I4
				//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)
				if (CalculatedSkillMods.TryGetValue(skilltype, out var value))
				{
					return value;
				}
				float num = 0f;
				if (SkillModifiers != null && SkillModifiers.Count > 0)
				{
					foreach (KeyValuePair<string, DeathSkillModifier> skillModifier in SkillModifiers)
					{
						if ((int)skillModifier.Value.skill == 999 || skillModifier.Value.skill == skilltype)
						{
							num += skillModifier.Value.bonusModifer;
						}
					}
				}
				CalculatedSkillMods.Add(skilltype, num);
				return num;
			}

			public string GetLootModifiersDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				if (DeathLootModifiers == null)
				{
					return stringBuilder.ToString();
				}
				foreach (KeyValuePair<string, DeathLootModifier> deathLootModifier in DeathLootModifiers)
				{
					stringBuilder.AppendLine(Localization.instance.Localize(string.Format("<color={0}>{1}%</color> $loot_desc_pt1 {2} $loot_desc_pt2 {3}", "#b9f2ff", deathLootModifier.Value.chance * 100f, deathLootModifier.Key, string.Join(",", deathLootModifier.Value.bonusActions))));
				}
				return stringBuilder.ToString();
			}

			public string GetSkillModiferDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				if (SkillModifiers == null)
				{
					return stringBuilder.ToString();
				}
				foreach (KeyValuePair<string, DeathSkillModifier> skillModifier in SkillModifiers)
				{
					if (skillModifier.Value.bonusModifer > 1f)
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("{0} +<color={1}>{2}%</color> $xp", skillModifier.Key, "#b9f2ff", Mathf.Round((skillModifier.Value.bonusModifer - 1f) * 100f))));
					}
					else
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("{0} -<color={1}>{2}%</color> $xp", skillModifier.Key, "#ff4040", Mathf.Round((1f - skillModifier.Value.bonusModifer) * 100f))));
					}
				}
				return stringBuilder.ToString();
			}

			public string GetResourceModiferDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				if (ResourceModifiers == null)
				{
					return stringBuilder.ToString();
				}
				foreach (KeyValuePair<string, DeathResourceModifier> resourceModifier in ResourceModifiers)
				{
					if (resourceModifier.Value.bonusModifer > 1f)
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("{0} $drops <color={1}>{2}%</color> $more {3}", resourceModifier.Key, "#b9f2ff", (resourceModifier.Value.bonusModifer - 1f) * 100f, string.Join(",", resourceModifier.Value.bonusActions))));
					}
					else
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("{0} $drops <color={1}>{2}%</color> $less {3}", resourceModifier.Key, "#ff4040", (1f - resourceModifier.Value.bonusModifer) * 100f, string.Join(",", resourceModifier.Value.bonusActions))));
					}
				}
				return stringBuilder.ToString();
			}

			public string GetDamageModifierDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				if (DamageTakenModifier != 1f)
				{
					if (DamageTakenModifier > 1f)
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$damage_taken +<color={0}>{1}%</color>", "#ff4040", Mathf.Round((DamageTakenModifier - 1f) * 100f))));
					}
					else
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$damage_taken -<color={0}>{1}%</color>", "#b9f2ff", Mathf.Round((1f - DamageTakenModifier) * 100f))));
					}
				}
				if (DamageDoneModifier != 1f)
				{
					if (DamageDoneModifier > 1f)
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$damage_dealt +<color={0}>{1}%</color>", "#b9f2ff", Mathf.Round((DamageDoneModifier - 1f) * 100f))));
					}
					else
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$damage_dealt -<color={0}>{1}%</color>", "#ff4040", Mathf.Round((1f - DamageDoneModifier) * 100f))));
					}
				}
				return stringBuilder.ToString();
			}

			public string GetDeathStyleDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				switch (DeathStyle.itemLossStyle)
				{
				case ItemLossStyle.None:
					stringBuilder.AppendLine(Localization.instance.Localize("$no_item_loss"));
					break;
				case ItemLossStyle.DestroyNonWeaponArmor:
					stringBuilder.AppendLine(Localization.instance.Localize("$no_equipment_loss"));
					break;
				case ItemLossStyle.DestroyAll:
					stringBuilder.AppendLine(Localization.instance.Localize("$all_item_loss"));
					break;
				case ItemLossStyle.DeathlinkBased:
					stringBuilder.AppendLine(Localization.instance.Localize("$limited_saved_deathlink"));
					stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$equipment_kept <color={0}>{1}</color> - <color={2}>{3}</color>", "#b9f2ff", DeathStyle.minEquipmentKept, "#b9f2ff", DeathStyle.maxEquipmentKept)));
					stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$items_kept <color={0}>{1}</color> - <color={2}>{3}</color>", "#b9f2ff", DeathStyle.minItemsKept, "#b9f2ff", DeathStyle.maxItemsKept)));
					break;
				}
				if (DeathStyle.itemLossStyle != ItemLossStyle.DestroyAll)
				{
					if (DeathStyle.itemSavedStyle == ItemSavedStyle.OnCharacter)
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$saved_to_character"));
					}
					else
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$saved_to_tombstone"));
					}
					if (DeathStyle.nonSkillCheckedItemAction == NonSkillCheckedItemAction.Tombstone)
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$non_skill_items_tombstone"));
					}
					if (DeathStyle.nonSkillCheckedItemAction == NonSkillCheckedItemAction.Save)
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$non_skill_items_character"));
					}
					if (DeathStyle.nonSkillCheckedItemAction == NonSkillCheckedItemAction.Destroy)
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$non_skill_items_destroy"));
					}
				}
				if (DeathStyle.foodLossOnDeath)
				{
					if (DeathStyle.foodLossUsesDeathlink)
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$food_loss_deathlink"));
					}
					else
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$food_loss"));
					}
				}
				if (DeathStyle.maxSkillLossPercentage == DeathStyle.minSkillLossPercentage)
				{
					stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$skill_loss_desc <color={0}>{1}%</color>", "#ff4040", DeathStyle.maxSkillLossPercentage * 100f)));
				}
				else
				{
					stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$skill_loss_desc <color={0}>{1}%</color> - <color={2}>{3}%</color> $influenced_by_deathlink", "#ff4040", DeathStyle.maxSkillLossPercentage * 100f, "#ff4040", DeathStyle.minSkillLossPercentage * 100f)));
				}
				return stringBuilder.ToString();
			}
		}

		public class DeathConfiguration
		{
			public string DeathChoiceLevel { get; set; }

			public int ChangesUsed { get; set; }
		}

		public class PlayerDeathConfiguration
		{
			public Dictionary<long, DeathConfiguration> selectedDeathStyle { get; set; }
		}

		public class LeaderboardEntry
		{
			public long PlayerID { get; set; }

			public string PlayerName { get; set; }

			public string DeathChoice { get; set; }

			public float FirstLifeSeconds { get; set; }

			public float LongestLifeSeconds { get; set; }

			public float TotalLifeSeconds { get; set; }

			public int DeathCount { get; set; }

			public float TotalDamage { get; set; }

			public int BossKills { get; set; }

			public int TreeChops { get; set; }

			public int Mines { get; set; }

			public int CraftsAndBuilds { get; set; }

			[YamlIgnore]
			public float AverageLifeSeconds
			{
				get
				{
					if (DeathCount <= 0)
					{
						return 0f;
					}
					return TotalLifeSeconds / (float)DeathCount;
				}
			}
		}

		public abstract class ZNetProperty<T>
		{
			protected readonly ZNetView zNetView;

			public string Key { get; private set; }

			public T DefaultValue { get; private set; }

			protected ZNetProperty(string key, ZNetView zNetView, T defaultValue)
			{
				Key = key;
				DefaultValue = defaultValue;
				this.zNetView = zNetView;
			}

			private void ClaimOwnership()
			{
				if (!zNetView.IsOwner())
				{
					zNetView.ClaimOwnership();
				}
			}

			public void Set(T value)
			{
				SetValue(value);
			}

			public void ForceSet(T value)
			{
				ClaimOwnership();
				Set(value);
			}

			public abstract T Get();

			protected abstract void SetValue(T value);
		}

		public class BoolZNetProperty : ZNetProperty<bool>
		{
			public BoolZNetProperty(string key, ZNetView zNetView, bool defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}

			public override bool Get()
			{
				return zNetView.GetZDO().GetBool(base.Key, base.DefaultValue);
			}

			protected override void SetValue(bool value)
			{
				zNetView.GetZDO().Set(base.Key, value);
			}
		}

		public class IntZNetProperty : ZNetProperty<int>
		{
			public IntZNetProperty(string key, ZNetView zNetView, int defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}

			public override int Get()
			{
				return zNetView.GetZDO().GetInt(base.Key, base.DefaultValue);
			}

			protected override void SetValue(int value)
			{
				zNetView.GetZDO().Set(base.Key, value);
			}
		}

		public class StringZNetProperty : ZNetProperty<string>
		{
			public StringZNetProperty(string key, ZNetView zNetView, string defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}

			public override string Get()
			{
				return zNetView.GetZDO().GetString(base.Key, base.DefaultValue);
			}

			protected override void SetValue(string value)
			{
				zNetView.GetZDO().Set(base.Key, value);
			}
		}

		public class Vector3ZNetProperty : ZNetProperty<Vector3>
		{
			public Vector3ZNetProperty(string key, ZNetView zNetView, Vector3 defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}//IL_0003: Unknown result type (might be due to invalid IL or missing references)


			public override Vector3 Get()
			{
				//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)
				return zNetView.GetZDO().GetVec3(base.Key, base.DefaultValue);
			}

			protected override void SetValue(Vector3 value)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				zNetView.GetZDO().Set(base.Key, value);
			}
		}

		public class DictionaryZNetProperty : ZNetProperty<Dictionary<SkillType, float>>
		{
			private BinaryFormatter binFormatter = new BinaryFormatter();

			public DictionaryZNetProperty(string key, ZNetView zNetView, Dictionary<SkillType, float> defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}

			public override Dictionary<SkillType, float> Get()
			{
				byte[] byteArray = zNetView.GetZDO().GetByteArray(base.Key, (byte[])null);
				if (byteArray == null)
				{
					return new Dictionary<SkillType, float>();
				}
				MemoryStream serializationStream = new MemoryStream(byteArray);
				return (Dictionary<SkillType, float>)binFormatter.Deserialize(serializationStream);
			}

			protected override void SetValue(Dictionary<SkillType, float> value)
			{
				MemoryStream memoryStream = new MemoryStream();
				binFormatter.Serialize(memoryStream, value);
				zNetView.GetZDO().Set(base.Key, memoryStream.ToArray());
			}

			public void UpdateDictionary()
			{
			}
		}

		public class ZDOIDZNetProperty : ZNetProperty<ZDOID>
		{
			public ZDOIDZNetProperty(string key, ZNetView zNetView, ZDOID defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}//IL_0003: Unknown result type (might be due to invalid IL or missing references)


			public override ZDOID Get()
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				return zNetView.GetZDO().GetZDOID(base.Key);
			}

			protected override void SetValue(ZDOID value)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				zNetView.GetZDO().Set(base.Key, value);
			}
		}

		public static IDeserializer yamldeserializer = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build();

		public static ISerializer yamlserializer = ((BuilderSkeleton<SerializerBuilder>)new SerializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).DisableAliases().ConfigureDefaultValuesHandling((DefaultValuesHandling)2)
			.Build();

		public static IDeserializer leaderboardDeserializer = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).IgnoreUnmatchedProperties().Build();

		public static readonly string DeathChoiceKey = "DL_DeathChoice";

		public static readonly string DeathChoiceChangesKey = "DL_ChoiceChanges";

		public static readonly string DamageTakenModifierKey = "DL_DmgTaken";

		public static readonly string DamageDoneModifierKey = "DL_DmgDone";

		public static readonly string LeaderboardFirstLifeKey = "DL_LBFirst";

		public static readonly string LeaderboardLongestLifeKey = "DL_LBLongest";

		public static readonly string LeaderboardTotalLifeKey = "DL_LBTotal";

		public static readonly string LeaderboardDeathCountKey = "DL_LBDeaths";

		public static readonly string LeaderboardDamageKey = "DL_LBDamage";

		private const string color_good = "#b9f2ff";

		private const string color_bad = "#ff4040";
	}
	internal static class DeathConfigurationData
	{
		[HarmonyPatch(typeof(Player))]
		public static class SetupPlayerDeathlink
		{
			[HarmonyPostfix]
			[HarmonyPatch("Load")]
			private static void Postfix(Player __instance)
			{
				CheckAndSetPlayerDeathConfig(__instance);
			}
		}

		public static readonly Dictionary<string, DataObjects.DeathChoiceLevel> defaultDeathLevels = new Dictionary<string, DataObjects.DeathChoiceLevel>
		{
			{
				"Vanilla",
				new DataObjects.DeathChoiceLevel
				{
					DisplayName = "Vanilla",
					DeathStyle = new DataObjects.DeathProgressionDetails
					{
						itemLossStyle = DataObjects.ItemLossStyle.None,
						foodLossOnDeath = true,
						itemSavedStyle = DataObjects.ItemSavedStyle.Tombstone,
						minSkillLossPercentage = 0.05f,
						maxSkillLossPercentage = 0.05f
					},
					DeathLootModifiers = new Dictionary<string, DataObjects.DeathLootModifier>(),
					ResourceModifiers = new Dictionary<string, DataObjects.DeathResourceModifier>(),
					SkillModifiers = new Dictionary<string, DataObjects.DeathSkillModifier>()
				}
			},
			{
				"Rougelike1",
				new DataObjects.DeathChoiceLevel
				{
					DisplayName = "ShieldBearer",
					DeathStyle = new DataObjects.DeathProgressionDetails
					{
						itemLossStyle = DataObjects.ItemLossStyle.DeathlinkBased,
						foodLossUsesDeathlink = true,
						itemSavedStyle = DataObjects.ItemSavedStyle.Tombstone,
						minEquipmentKept = 3,
						maxEquipmentKept = 9,
						minItemsKept = 3,
						maxItemsKept = 15,
						minItemsKeptChoices = 1,
						maxItemsKeptChoices = 5,
						minSkillLossPercentage = 0.03f,
						maxSkillLossPercentage = 0.13f
					},
					DeathLootModifiers = new Dictionary<string, DataObjects.DeathLootModifier>(),
					ResourceModifiers = new Dictionary<string, DataObjects.DeathResourceModifier> { 
					{
						"Wood",
						new DataObjects.DeathResourceModifier
						{
							prefabs = new List<string> { "Wood", "FineWood", "RoundLog", "YggdrasilWood", "Blackwood" },
							bonusModifer = 1.1f,
							bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Harvesting }
						}
					} },
					SkillModifiers = new Dictionary<string, DataObjects.DeathSkillModifier> { 
					{
						"All",
						new DataObjects.DeathSkillModifier
						{
							bonusModifer = 1.05f,
							skill = (SkillType)999
						}
					} }
				}
			},
			{
				"Rougelike2",
				new DataObjects.DeathChoiceLevel
				{
					DisplayName = "Raider",
					DeathStyle = new DataObjects.DeathProgressionDetails
					{
						itemLossStyle = DataObjects.ItemLossStyle.DeathlinkBased,
						itemSavedStyle = DataObjects.ItemSavedStyle.Tombstone,
						minEquipmentKept = 2,
						maxEquipmentKept = 6,
						minItemsKeptChoices = 1,
						maxItemsKeptChoices = 3,
						minSkillLossPercentage = 0.02f,
						maxSkillLossPercentage = 0.14f
					},
					DeathLootModifiers = new Dictionary<string, DataObjects.DeathLootModifier>(),
					ResourceModifiers = new Dictionary<string, DataObjects.DeathResourceModifier>
					{
						{
							"Wood",
							new DataObjects.DeathResourceModifier
							{
								prefabs = new List<string> { "Wood", "FineWood", "RoundLog", "YggdrasilWood", "Blackwood" },
								bonusModifer = 1.2f,
								bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Harvesting }
							}
						},
						{
							"Ore",
							new DataObjects.DeathResourceModifier
							{
								prefabs = new List<string> { "CopperOre", "TinOre", "IronScrap", "SilverOre", "BlackMetalScrap", "CopperScrap", "FlametalOreNew" },
								bonusModifer = 1.2f,
								bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Harvesting }
							}
						}
					},
					SkillModifiers = new Dictionary<string, DataObjects.DeathSkillModifier> { 
					{
						"All",
						new DataObjects.DeathSkillModifier
						{
							bonusModifer = 1.1f,
							skill = (SkillType)999
						}
					} }
				}
			},
			{
				"Rougelike3",
				new DataObjects.DeathChoiceLevel
				{
					DisplayName = "Berserker",
					DamageTakenModifier = 1.15f,
					DamageDoneModifier = 1.1f,
					DeathStyle = new DataObjects.DeathProgressionDetails
					{
						itemLossStyle = DataObjects.ItemLossStyle.DeathlinkBased,
						itemSavedStyle = DataObjects.ItemSavedStyle.OnCharacter,
						minEquipmentKept = 0,
						maxEquipmentKept = 3,
						minItemsKeptChoices = 0,
						maxItemsKeptChoices = 2,
						minSkillLossPercentage = 0.05f,
						maxSkillLossPercentage = 0.2f
					},
					DeathLootModifiers = new Dictionary<string, DataObjects.DeathLootModifier> { 
					{
						"AmberPearl",
						new DataObjects.DeathLootModifier
						{
							chance = 0.05f,
							prefab = "AmberPearl",
							bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Kills }
						}
					} },
					ResourceModifiers = new Dictionary<string, DataObjects.DeathResourceModifier>
					{
						{
							"Wood",
							new DataObjects.DeathResourceModifier
							{
								prefabs = new List<string> { "Wood", "FineWood", "RoundLog", "YggdrasilWood", "Blackwood" },
								bonusModifer = 1.5f,
								bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Harvesting }
							}
						},
						{
							"Ore",
							new DataObjects.DeathResourceModifier
							{
								prefabs = new List<string> { "CopperOre", "TinOre", "IronScrap", "SilverOre", "BlackMetalScrap", "CopperScrap", "FlametalOreNew" },
								bonusModifer = 1.5f,
								bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Harvesting }
							}
						}
					},
					SkillModifiers = new Dictionary<string, DataObjects.DeathSkillModifier> { 
					{
						"All",
						new DataObjects.DeathSkillModifier
						{
							bonusModifer = 1.2f,
							skill = (SkillType)999
						}
					} }
				}
			},
			{
				"Hardcore",
				new DataObjects.DeathChoiceLevel
				{
					DisplayName = "Deathbringer",
					DamageTakenModifier = 1.25f,
					DamageDoneModifier = 1.15f,
					DeathStyle = new DataObjects.DeathProgressionDetails
					{
						itemLossStyle = DataObjects.ItemLossStyle.DestroyAll,
						minSkillLossPercentage = 0.05f,
						maxSkillLossPercentage = 0.25f
					},
					DeathLootModifiers = new Dictionary<string, DataObjects.DeathLootModifier>
					{
						{
							"AmberPearl",
							new DataObjects.DeathLootModifier
							{
								chance = 0.05f,
								prefab = "AmberPearl",
								bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Kills }
							}
						},
						{
							"SmallHealthPotion",
							new DataObjects.DeathLootModifier
							{
								chance = 0.01f,
								prefab = "MeadHealthMinor",
								bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Kills }
							}
						}
					},
					ResourceModifiers = new Dictionary<string, DataObjects.DeathResourceModifier>
					{
						{
							"Wood",
							new DataObjects.DeathResourceModifier
							{
								prefabs = new List<string> { "Wood", "FineWood", "RoundLog", "YggdrasilWood", "Blackwood", "ElderBark" },
								bonusModifer = 2f,
								bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Harvesting }
							}
						},
						{
							"Stone",
							new DataObjects.DeathResourceModifier
							{
								prefabs = new List<string> { "Flint", "Stone", "BlackMarble", "Grausten" },
								bonusModifer = 2f,
								bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Harvesting }
							}
						},
						{
							"Ore",
							new DataObjects.DeathResourceModifier
							{
								prefabs = new List<string> { "CopperOre", "TinOre", "IronScrap", "SilverOre", "BlackMetalScrap", "CopperScrap", "FlametalOreNew" },
								bonusModifer = 2f,
								bonusActions = new List<DataObjects.ResourceGainTypes> { DataObjects.ResourceGainTypes.Harvesting }
							}
						}
					},
					SkillModifiers = new Dictionary<string, DataObjects.DeathSkillModifier> { 
					{
						"All",
						new DataObjects.DeathSkillModifier
						{
							bonusModifer = 1.3f,
							skill = (SkillType)999
						}
					} }
				}
			}
		};

		public static Dictionary<long, DataObjects.DeathConfiguration> playerSettings = new Dictionary<long, DataObjects.DeathConfiguration>();

		public static Dictionary<string, DataObjects.DeathChoiceLevel> DeathLevels = defaultDeathLevels;

		public static DataObjects.DeathChoiceLevel playerDeathConfiguration = new DataObjects.DeathChoiceLevel
		{
			DeathStyle = new DataObjects.DeathProgressionDetails
			{
				foodLossOnDeath = true,
				foodLossUsesDeathlink = false,
				itemLossStyle = DataObjects.ItemLossStyle.None,
				minItemsKept = 0,
				maxItemsKept = 0,
				minEquipmentKept = 0,
				maxEquipmentKept = 0,
				skillLossOnDeath = true,
				maxSkillLossPercentage = 0.05f,
				minSkillLossPercentage = 0.05f,
				itemSavedStyle = DataObjects.ItemSavedStyle.Tombstone,
				nonSkillCheckedItemAction = DataObjects.NonSkillCheckedItemAction.Tombstone
			}
		};

		internal static void Init()
		{
			try
			{
				UpdateDeathLevelsConfig(File.ReadAllText(ValConfig.deathChoicesPath));
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"There was an error updating the Death choice Level values, defaults will be used. Exception: {arg}");
			}
			try
			{
				UpdatePlayerConfigSettings(File.ReadAllText(ValConfig.playerSettingsPath));
			}
			catch (Exception arg2)
			{
				Logger.LogWarning((object)$"There was an error updating the player choice configs, defaults will be used. Exception: {arg2}");
			}
		}

		public static void CheckAndSetPlayerDeathConfig(Player player)
		{
			if (ValConfig.UsePrivateKeysForDeathChoice.Value)
			{
				Logger.LogDebug("Checking private keys configurations for Deathlink");
				if (!player.PlayerHasUniqueKey(DataObjects.DeathChoiceKey))
				{
					string validDefaultChoiceKey = GetValidDefaultChoiceKey();
					if (validDefaultChoiceKey != null)
					{
						Logger.LogInfo("No stored Deathlink choice, assigning configured default '" + validDefaultChoiceKey + "'.");
						player.AddUniqueKeyValue(DataObjects.DeathChoiceKey, validDefaultChoiceKey);
					}
				}
				if (player.PlayerHasUniqueKey(DataObjects.DeathChoiceKey))
				{
					string text = default(string);
					player.TryGetUniqueKeyValue(DataObjects.DeathChoiceKey, ref text);
					if (DeathLevels.ContainsKey(text))
					{
						Logger.LogDebug("Player deathlink configurations set " + text);
						playerDeathConfiguration = DeathLevels[text];
					}
					else
					{
						Logger.LogDebug("Player preference setting is not an available config, removing player choice.");
						player.PlayerRemoveUniqueKey(DataObjects.DeathChoiceKey);
						CheckAndSetPlayerDeathConfig(player);
					}
				}
			}
			else
			{
				CheckYamlConfig();
			}
			StoreDamageModifiersOnPlayer(player);
		}

		public static void StoreDamageModifiersOnPlayer(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			ZNetView nview = ((Character)player).m_nview;
			if (!((Object)(object)nview == (Object)null) && nview.IsValid())
			{
				ZDO zDO = nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set(DataObjects.DamageTakenModifierKey, playerDeathConfiguration.DamageTakenModifier);
					zDO.Set(DataObjects.DamageDoneModifierKey, playerDeathConfiguration.DamageDoneModifier);
					Logger.LogDebug($"Stored damage modifiers on player ZDO: taken {playerDeathConfiguration.DamageTakenModifier}, done {playerDeathConfiguration.DamageDoneModifier}");
				}
			}
		}

		public static void ResetLocalPlayerChoice()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				Logger.LogWarning("Cannot reset death choice, local player is not set.");
				return;
			}
			localPlayer.PlayerRemoveUniqueKey(DataObjects.DeathChoiceKey);
			localPlayer.PlayerRemoveUniqueKey(DataObjects.DeathChoiceChangesKey);
			playerDeathConfiguration = DeathLevels.First().Value;
			CheckAndSetPlayerDeathConfig(localPlayer);
			WritePlayerChoices();
			Logger.LogInfo("Local player's death choice has been reset.");
		}

		internal static void CheckYamlConfig()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				Logger.LogWarning("Local player not defined, skipping setup.");
				DeathLevels = defaultDeathLevels;
				Logger.LogDebug("Player preference setting is not an available config, using fallback " + DeathLevels.First().Key);
				playerDeathConfiguration = DeathLevels.First().Value;
				return;
			}
			long playerID = Player.m_localPlayer.GetPlayerID();
			Logger.LogDebug($"Setting up Deathlink player configuration with id {playerID}");
			Logger.LogDebug(string.Format("Checking stored configurations for {0} {1}", playerID, string.Join(",", playerSettings.Keys)));
			if (playerSettings.ContainsKey(playerID))
			{
				string deathChoiceLevel = playerSettings[playerID].DeathChoiceLevel;
				if (DeathLevels.ContainsKey(deathChoiceLevel))
				{
					Logger.LogDebug("Player deathlink configurations set " + deathChoiceLevel);
					playerDeathConfiguration = DeathLevels[deathChoiceLevel];
				}
				else
				{
					Logger.LogDebug("Player preference setting is not an available config, using fallback");
					playerDeathConfiguration = DeathLevels.First().Value;
				}
				return;
			}
			string validDefaultChoiceKey = GetValidDefaultChoiceKey();
			if (validDefaultChoiceKey != null)
			{
				Logger.LogInfo($"No stored Deathlink choice for {playerID}, assigning configured default '{validDefaultChoiceKey}'.");
				playerSettings.Add(playerID, new DataObjects.DeathConfiguration
				{
					DeathChoiceLevel = validDefaultChoiceKey
				});
				playerDeathConfiguration = DeathLevels[validDefaultChoiceKey];
				WritePlayerChoices();
			}
		}

		public static string PlayerSettingsDefaultConfig()
		{
			return DataObjects.yamlserializer.Serialize((object)playerSettings);
		}

		public static string DeathLevelsYamlDefaultConfig()
		{
			return DataObjects.yamlserializer.Serialize((object)DeathLevels);
		}

		public static void WriteDeathChoices()
		{
			File.WriteAllText(ValConfig.deathChoicesPath, DataObjects.yamlserializer.Serialize((object)DeathLevels));
		}

		public static void WritePlayerChoices()
		{
			File.WriteAllText(ValConfig.playerSettingsPath, DataObjects.yamlserializer.Serialize((object)playerSettings));
		}

		public static string GetValidDefaultChoiceKey()
		{
			string value = ValConfig.DefaultDeathChoice.Value;
			if (string.IsNullOrEmpty(value))
			{
				return null;
			}
			if (DeathLevels.ContainsKey(value))
			{
				return value;
			}
			Logger.LogWarning("Configured DefaultDeathChoice '" + value + "' is not a known death choice, the selection popup will be used instead.");
			return null;
		}

		public static int GetPlayerChangesUsed(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return 0;
			}
			if (ValConfig.UsePrivateKeysForDeathChoice.Value)
			{
				string s = default(string);
				if (player.TryGetUniqueKeyValue(DataObjects.DeathChoiceChangesKey, ref s) && int.TryParse(s, out var result))
				{
					return result;
				}
				return 0;
			}
			long playerID = player.GetPlayerID();
			if (playerSettings.ContainsKey(playerID))
			{
				return playerSettings[playerID].ChangesUsed;
			}
			return 0;
		}

		public static void IncrementPlayerChangesUsed(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			int changesUsed = GetPlayerChangesUsed(player) + 1;
			if (ValConfig.UsePrivateKeysForDeathChoice.Value)
			{
				player.PlayerRemoveUniqueKey(DataObjects.DeathChoiceChangesKey);
				player.AddUniqueKeyValue(DataObjects.DeathChoiceChangesKey, changesUsed.ToString());
				return;
			}
			long playerID = player.GetPlayerID();
			if (playerSettings.ContainsKey(playerID))
			{
				playerSettings[playerID].ChangesUsed = changesUsed;
			}
			else
			{
				playerSettings.Add(playerID, new DataObjects.DeathConfiguration
				{
					ChangesUsed = changesUsed
				});
			}
			WritePlayerChoices();
		}

		public static bool PlayerCanChangeChoice(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			return GetPlayerChangesUsed(player) < ValConfig.AllowedDeathChoiceChanges.Value;
		}

		public static void UpdateDeathLevelsConfig(string rawyaml)
		{
			Dictionary<string, DataObjects.DeathChoiceLevel> dictionary = DataObjects.yamldeserializer.Deserialize<Dictionary<string, DataObjects.DeathChoiceLevel>>(rawyaml);
			if (dictionary == null || dictionary.Count == 0)
			{
				Logger.LogWarning("DeathChoices config is empty or could not be parsed, using built-in defaults.");
				DeathLevels = defaultDeathLevels;
			}
			else
			{
				DeathLevels = dictionary;
			}
		}

		public static void UpdatePlayerConfigSettings(string rawyaml)
		{
			foreach (KeyValuePair<long, DataObjects.DeathConfiguration> item in DataObjects.yamldeserializer.Deserialize<Dictionary<long, DataObjects.DeathConfiguration>>(rawyaml))
			{
				if (!playerSettings.ContainsKey(item.Key))
				{
					playerSettings.Add(item.Key, item.Value);
				}
			}
		}
	}
	internal static class Utils
	{
		public static CodeMatcher CreateLabelOffset(this CodeMatcher matcher, out Label label, int offset = 0)
		{
			return matcher.CreateLabelAt(matcher.Pos + offset, ref label);
		}

		public static bool PlayerHasUniqueKey(this Player player, string key)
		{
			foreach (string uniqueKey in player.GetUniqueKeys())
			{
				if (uniqueKey.StartsWith(key))
				{
					return true;
				}
			}
			return false;
		}

		public static bool PlayerRemoveUniqueKey(this Player player, string key)
		{
			foreach (string uniqueKey in player.GetUniqueKeys())
			{
				if (uniqueKey.StartsWith(key))
				{
					((Humanoid)player).RemoveUniqueKey(uniqueKey);
					return true;
				}
			}
			return false;
		}

		public static void SafeInsertOrAppend(this Dictionary<DataObjects.ItemResults, List<ItemData>> dict, DataObjects.ItemResults key, List<ItemData> value)
		{
			if (!dict.ContainsKey(key))
			{
				dict.Add(key, value);
			}
			else
			{
				dict[key].AddRange(value);
			}
		}

		public static void SafeInsertOrAppend(this Dictionary<DataObjects.ItemResults, List<ItemData>> dict, DataObjects.ItemResults key, ItemData value)
		{
			if (!dict.ContainsKey(key))
			{
				dict.Add(key, new List<ItemData> { value });
			}
			else
			{
				dict[key].Add(value);
			}
		}
	}
	public class ValConfig
	{
		public static ConfigFile cfg;

		public static ConfigEntry<bool> EnableDebugMode;

		public static ConfigEntry<string> ItemsNotSkillChecked;

		public static ConfigEntry<float> SkillGainOnKills;

		public static ConfigEntry<float> SkillGainOnBossKills;

		public static ConfigEntry<float> SkillGainOnCrafts;

		public static ConfigEntry<float> SkillGainOnResourceGathering;

		public static ConfigEntry<float> SkillGainOnBuilding;

		public static ConfigEntry<bool> ShowDeathMapMarker;

		public static ConfigEntry<bool> UsePrivateKeysForDeathChoice;

		public static ConfigEntry<string> DefaultDeathChoice;

		public static ConfigEntry<int> AllowedDeathChoiceChanges;

		public static ConfigEntry<bool> EnableAlmanacClassesXPLossOnDeath;

		public static ConfigEntry<float> AlmanacClassesXPLossScale;

		public static ConfigEntry<float> AlmanacClassesXPGainScale;

		public static ConfigEntry<bool> EnableWackyMMOXPLossOnDeath;

		public static ConfigEntry<float> WackyMMOXPLossScale;

		public static ConfigEntry<float> WackyMMOXPGainScale;

		public static ConfigEntry<bool> EnableLeaderboard;

		public static ConfigEntry<float> LeaderboardSyncInterval;

		private const string cfgFolder = "Deathlink";

		private const string deathChoicesCfg = "DeathChoices.yaml";

		private const string deathSettingsCfg = "CharacterSettings.yaml";

		private const string leaderboardCfg = "leaderboard.yaml";

		internal static string deathChoicesPath = Path.Combine(Paths.ConfigPath, "Deathlink", "DeathChoices.yaml");

		internal static string playerSettingsPath = Path.Combine(Paths.ConfigPath, "Deathlink", "CharacterSettings.yaml");

		internal static string leaderboardPath = Path.Combine(Paths.ConfigPath, "Deathlink", "leaderboard.yaml");

		private static CustomRPC deathChoiceRPC;

		private static CustomRPC characterSettingRPC;

		public static CustomRPC resetChoiceRPC;

		public static ConfigEntry<float> SkillProgressUpdateCheckInterval;

		public ValConfig(ConfigFile Config)
		{
			cfg = Config;
			cfg.SaveOnConfigSet = true;
			CreateConfigValues(Config);
			SetupConfigRPCs();
			LoadYamlConfigs();
		}

		public static string GetSecondaryConfigDirectoryPath()
		{
			return Directory.CreateDirectory(Path.Combine(Paths.ConfigPath, "Deathlink")).FullName;
		}

		public void SetupConfigRPCs()
		{
			//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
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_007f: Expected O, but got Unknown
			deathChoiceRPC = NetworkManager.Instance.AddRPC("DEATHLK_CH", new CoroutineHandler(OnServerRecieveConfigs), new CoroutineHandler(OnClientReceiveDeathChoiceConfigs));
			characterSettingRPC = NetworkManager.Instance.AddRPC("DEATHLK_PSET", new CoroutineHandler(OnServerRecievePlayerSettingsConfig), new CoroutineHandler(OnClientReceivePlayerSettingsConfigs));
			resetChoiceRPC = NetworkManager.Instance.AddRPC("DEATHLK_RESET", new CoroutineHandler(OnServerRecieveResetRPC), new CoroutineHandler(OnClientRecieveResetRPC));
			SynchronizationManager.Instance.AddInitialSynchronization(deathChoiceRPC, (Func<ZPackage>)SendDeathChoices);
			SynchronizationManager.Instance.AddInitialSynchronization(characterSettingRPC, (Func<ZPackage>)SendCharSettings);
			LeaderboardData.SetupRPC();
		}

		private void CreateConfigValues(ConfigFile Config)
		{
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Expected O, but got Unknown
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Expected O, but got Unknown
			ItemsNotSkillChecked = BindServerConfig("DeathProgression", "ItemsNotSkillChecked", "Tin,TinOre,Copper,CopperOre,CopperScrap,Bronze,Iron,IronScrap,Silver,SilverOre,DragonEgg,chest_hildir1,chest_hildir2,chest_hildir3,BlackMetal,BlackMetalScrap,DvergrNeedle,MechanicalSpring,FlametalNew,FlametalOreNew", "List of items that are not rolled to be saved through death progression.");
			SkillGainOnKills = BindServerConfig("DeathSkillGain", "SkillGainOnKills", 5f, "Skill Gain from killing non-boss creatures.");
			SkillGainOnBossKills = BindServerConfig("DeathSkillGain", "SkillGainOnBossKills", 20f, "Skill Gain from killing boss creatures.");
			SkillGainOnCrafts = BindServerConfig("DeathSkillGain", "SkillGainOnCrafts", 0.8f, "Skill Gain from crafting.");
			SkillGainOnResourceGathering = BindServerConfig("DeathSkillGain", "SkillGainOnResourceGathering", 0.1f, "Skill Gain from resource gathering.");
			SkillGainOnBuilding = BindServerConfig("DeathSkillGain", "SkillGainOnBuilding", 0.5f, "Skill Gain from building.");
			SkillProgressUpdateCheckInterval = BindServerConfig("DeathSkillGain", "SkillProgressUpdateCheckInterval", 1f, "How frequently skill gains are computed and added. More frequently means smaller xp gains more often.", advanced: true, 0.1f, 5f);
			ShowDeathMapMarker = BindServerConfig("DeathTweaks", "ShowDeathMapMarker", value: true, "Whether or not a map marker is placed on your death location.");
			UsePrivateKeysForDeathChoice = BindServerConfig("Config", "UsePrivateKeysForDeathChoice", value: true, "If true, death configuration is stored and checked as a private key on the player. Key value is synced when connecting to a server. False uses the yaml configuration flatfile.", null, advanced: true);
			DefaultDeathChoice = BindServerConfig("Config", "DefaultDeathChoice", "", "Death choice key (eg. Vanilla, Rougelike1) that new players are automatically assigned the first time they join, skipping the selection popup. Leave empty to show the selection popup instead.");
			AllowedDeathChoiceChanges = BindServerConfig("Config", "AllowedDeathChoiceChanges", 1, "How many times a player may change their Deathlink choice from the compendium. 0 disables the change button.", advanced: false, 0, 10);
			EnableAlmanacClassesXPLossOnDeath = BindServerConfig("ModIntegrations", "EnableAlmanacClassesXPLossOnDeath", value: true, "If true, XP loss also happens for characters Alamanc Class level.");
			AlmanacClassesXPLossScale = BindServerConfig("ModIntegrations", "AlmanacClassesXPLossScale", 1f, "How strong the XP loss for Almanac is, lower = less XP loss, higher = more XP loss.");
			AlmanacClassesXPGainScale = BindServerConfig("ModIntegrations", "AlmanacClassesXPGainScale", 20f, "How much Almanac Classes XP is gained based on Deathlink actions. This is gained at an inregular interval based on deathlink skill gains.");
			EnableWackyMMOXPLossOnDeath = BindServerConfig("ModIntegrations", "EnableWackyMMOXPLossOnDeath", value: true, "If true, XP loss also happens for characters WackyMMO level.");
			WackyMMOXPLossScale = BindServerConfig("ModIntegrations", "WackyMMOXPLossScale", 1f, "How strong the XP loss for WackyMMO is, lower = less XP loss, higher = more XP loss.");
			WackyMMOXPGainScale = BindServerConfig("ModIntegrations", "WackyMMOXPGainScale", 1f, "How strong the XP gain for WackyMMO is, lower = less XP gain, higher = more XP gain.");
			EnableLeaderboard = BindServerConfig("Leaderboard", "EnableLeaderboard", value: true, "Whether the server-tracked leaderboard (shown in the Trophies tab) is enabled.");
			LeaderboardSyncInterval = BindServerConfig("Leaderboard", "LeaderboardSyncInterval", 30f, "How often (in minutes) clients report their stats to the server and the server broadcasts the leaderboard back to clients.", advanced: false, 5f, 120f);
			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();
		}

		internal void LoadYamlConfigs()
		{
			string[] files = Directory.GetFiles(GetSecondaryConfigDirectoryPath());
			bool flag = false;
			bool flag2 = false;
			string[] array = files;
			foreach (string text in array)
			{
				if (text.Contains("DeathChoices.yaml"))
				{
					Logger.LogDebug("Found Deathchoice configuration: " + text);
					deathChoicesPath = text;
					flag = true;
				}
				if (text.Contains("CharacterSettings.yaml"))
				{
					Logger.LogDebug("Found Character configuration: " + text);
					playerSettingsPath = text;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Logger.LogDebug("Death Choices missing, recreating.");
				using StreamWriter streamWriter = new StreamWriter(deathChoicesPath);
				string value = "#################################################\n# Deathlink - Death Choice Configuration\n#################################################\n";
				streamWriter.WriteLine(value);
				streamWriter.WriteLine(DeathConfigurationData.DeathLevelsYamlDefaultConfig());
			}
			if (!flag2)
			{
				Logger.LogDebug("Character Settings missing, recreating.");
				using StreamWriter streamWriter2 = new StreamWriter(playerSettingsPath);
				string value2 = "#################################################\n# Deathlink - Character settings\n#################################################\n";
				streamWriter2.WriteLine(value2);
				streamWriter2.WriteLine(DeathConfigurationData.PlayerSettingsDefaultConfig());
			}
			SetupFileWatcher("DeathChoices.yaml");
			SetupFileWatcher("CharacterSettings.yaml");
		}

		private void SetupFileWatcher(string filtername)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
			fileSystemWatcher.Path = GetSecondaryConfigDirectoryPath();
			fileSystemWatcher.NotifyFilter = NotifyFilters.LastWrite;
			fileSystemWatcher.Filter = filtername;
			fileSystemWatcher.Changed += UpdateConfigFileOnChange;
			fileSystemWatcher.Created += UpdateConfigFileOnChange;
			fileSystemWatcher.Renamed += UpdateConfigFileOnChange;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private static void UpdateConfigFileOnChange(object sender, FileSystemEventArgs e)
		{
			if (!SynchronizationManager.Instance.PlayerIsAdmin)
			{
				Logger.LogDebug("Player is not an admin, and not allowed to change local configuration. Ignoring.");
			}
			else if (File.Exists(e.FullPath))
			{
				string rawyaml = File.ReadAllText(e.FullPath);
				FileInfo fileInfo = new FileInfo(e.FullPath);
				Logger.LogDebug("Filewatch changes from: (" + fileInfo.Name + ") " + fileInfo.FullName);
				if (fileInfo.Name == "DeathChoices.yaml")
				{
					Logger.LogDebug("Triggering Death Choices Settings update.");
					DeathConfigurationData.UpdateDeathLevelsConfig(rawyaml);
					deathChoiceRPC.SendPackage(ZNet.instance.m_peers, SendFileAsZPackage(e.FullPath));
				}
			}
		}

		private static IEnumerator OnClientReceiveDeathChoiceConfigs(long sender, ZPackage package)
		{
			DeathConfigurationData.UpdateDeathLevelsConfig(package.ReadString());
			DeathConfigurationData.WriteDeathChoices();
			yield return null;
		}

		private static IEnumerator OnServerRecieveConfigs(long sender, ZPackage package)
		{
			yield return null;
		}

		private static IEnumerator OnServerRecievePlayerSettingsConfig(long sender, ZPackage package)
		{
			DeathConfigurationData.UpdatePlayerConfigSettings(package.ReadString());
			DeathConfigurationData.WritePlayerChoices();
			yield return null;
		}

		private static IEnumerator OnServerRecieveResetRPC(long sender, ZPackage package)
		{
			string text = package.ReadString();
			Logger.LogInfo($"Received reset request for platform ID {text} from sender {sender}.");
			long num = 0L;
			long num2 = 0L;
			string text2 = "";
			foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
			{
				PlayerInfo current = player;
				Logger.LogInfo($"Checking player {current.m_userInfo.m_displayName} with platform ID {current.m_userInfo.m_id.m_userID} and character ID {((ZDOID)(ref current.m_characterID)).ID} | requested: {text}");
				if (((ZDOID)(ref current.m_characterID)).ID == 0)
				{
					Logger.LogWarning("Player " + current.m_userInfo.m_displayName + " has an invalid character ID of 0. This player is invalid and will be skipped.");
					continue;
				}
				long num3 = ((ZDOID)(ref current.m_characterID)).ID;
				if (num3 == 0L)
				{
					num3 = ZDOMan.instance.GetZDO(current.m_characterID).GetLong(ZDOVars.s_playerID, 0L);
				}
				if (current.m_userInfo.m_id.m_userID == text)
				{
					Logger.LogInfo($"Match found for player {current.m_userInfo.m_displayName} with platform ID {text} and character ID {num3}.");
					num = num3;
					if (DeathConfigurationData.playerSettings.ContainsKey(num))
					{
						Logger.LogInfo($"Removing stored death configuration for character ID {num}.");
						DeathConfigurationData.playerSettings.Remove(num);
					}
					foreach (ZNetPeer peer in ZNet.instance.GetPeers())
					{
						if (peer.m_socket != null && peer.m_socket.GetHostName() == text)
						{
							Logger.LogInfo($"Match found for peer {peer.m_playerName} with UID {peer.m_uid} and platform ID {text}. Setting targetPeerUID for reset RPC.");
							num2 = peer.m_uid;
							break;
						}
					}
				}
				try
				{
					if ((Object)(object)Player.m_localPlayer != (Object)null && current.m_characterID == ((Character)Player.m_localPlayer).m_nview.GetZDO().m_uid)
					{
						text2 = current.m_userInfo.m_id.m_userID;
					}
				}
				catch
				{
					Logger.LogWarning($"Failed to get platform ID for player {current.m_userInfo.m_displayName} with character ID {((ZDOID)(ref current.m_characterID)).ID}. This may cause issues with resetting death choices for the local player.");
				}
			}
			DeathConfigurationData.WritePlayerChoices();
			Logger.LogInfo($"Reset requested for platform ID {text} (charID: {num}, peerUID: {num2}), local platform ID: {text2}.");
			if (!string.IsNullOrEmpty(text2) && text2 == text)
			{
				DeathConfigurationData.ResetLocalPlayerChoice();
			}
			else if (num2 != 0L)
			{
				ZPackage val = new ZPackage();
				val.Write(text);
				resetChoiceRPC.SendPackage(num2, val);
			}
			else
			{
				Logger.LogWarning("No connected target found for platform ID " + text + "; reset was not delivered to any client.");
			}
			yield return null;
		}

		private static IEnumerator OnClientRecieveResetRPC(long sender, ZPackage package)
		{
			Logger.LogInfo("Reset requested for local players death choice.");
			DeathConfigurationData.ResetLocalPlayerChoice();
			yield return null;
		}

		private static IEnumerator OnClientReceivePlayerSettingsConfigs(long sender, ZPackage package)
		{
			DeathConfigurationData.UpdatePlayerConfigSettings(package.ReadString());
			yield return null;
		}

		private static ZPackage SendFileAsZPackage(string filepath)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			string text = File.ReadAllText(filepath);
			ZPackage val = new ZPackage();
			val.Write(text);
			return val;
		}

		private static ZPackage SendCharSettings()
		{
			return SendFileAsZPackage(playerSettingsPath);
		}

		private static ZPackage SendDeathChoices()
		{
			return SendFileAsZPackage(deathChoicesPath);
		}

		public static ConfigEntry<bool> BindServerConfig(string catagory, 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>(catagory, key, value, new ConfigDescription(description, acceptableValues, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}

		public static ConfigEntry<int> BindServerConfig(string catagory, 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>(catagory, 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<float> BindServerConfig(string catagory, 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>(catagory, 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<string> BindServerConfig(string catagory, 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>(catagory, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)acceptableValues, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}
	}
}