using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using SimpleJson;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using ValhallEternal.boons;
using ValhallEternal.common;
using ValhallEternal.modules;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ValhallEternal")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValhallEternal")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("0.7.6")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.7.6.0")]
namespace ValhallEternal
{
	internal class Logger
	{
		public static LogLevel Level = (LogLevel)16;

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

		public static void CheckEnableDebugLogging()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)Level >= 32)
			{
				ValhallEternal.Log.LogInfo((object)message);
			}
		}

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

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

		public static void LogError(string message)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)Level >= 2)
			{
				ValhallEternal.Log.LogError((object)message);
			}
		}
	}
	[BepInPlugin("MidnightsFX.ValhallaEternal", "ValhallEternal", "0.7.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	internal class ValhallEternal : BaseUnityPlugin
	{
		public const string PluginGUID = "MidnightsFX.ValhallaEternal";

		public const string PluginName = "ValhallEternal";

		public const string PluginVersion = "0.7.6";

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

		public static AssetBundle EmbeddedResourceBundle;

		internal static Harmony Harmony = new Harmony("MidnightsFX.ValhallaEternal");

		public static ManualLogSource Log;

		public ValConfig cfg;

		public static Harmony HarmonyInstance { get; private set; }

		public void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			cfg = new ValConfig(((BaseUnityPlugin)this).Config);
			EmbeddedResourceBundle = AssetUtils.LoadAssetBundleFromResources("ValhallEternal.embedded.valeternal", typeof(ValhallEternal).Assembly);
			Deities.LoadDietyConfigurations();
			HarmonyInstance = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "MidnightsFX.ValhallaEternal");
			AddLocalizations();
			SacrificeData.SetupSacrificeData();
			DataObjects.LoadAssets();
			Commands.AddCommands();
			Locations.SetupLocations();
			Logger.LogInfo((object)"Live eternal in Valhalla.");
		}

		private void AddLocalizations()
		{
			Localization = LocalizationManager.Instance.GetLocalization();
			string text = Path.Combine(Paths.ConfigPath, "ValhallaEternal", "localizations");
			Directory.CreateDirectory(text);
			string[] manifestResourceNames = typeof(ValhallEternal).Assembly.GetManifestResourceNames();
			foreach (string text2 in manifestResourceNames)
			{
				if (!text2.Contains("localizations"))
				{
					continue;
				}
				string input = ReadEmbeddedResourceFile(text2);
				string text3 = Regex.Replace(input, "\\/\\/.*", "");
				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 Dictionary<string, string> UpdateLocalizationWithMissingKeys(Dictionary<string, string> internal_localization, Dictionary<string, string> cached_localization)
		{
			if (internal_localization.Keys != cached_localization.Keys)
			{
				List<string> list = cached_localization.Keys.ToList();
				foreach (KeyValuePair<string, string> item in internal_localization)
				{
					list.Remove(item.Key);
					if (!cached_localization.ContainsKey(item.Key))
					{
						((BaseUnityPlugin)this).Logger.LogDebug((object)("Adding missing localization key " + item.Key));
						cached_localization.Add(item.Key, item.Value);
					}
				}
				if (list.Count > 0)
				{
					((BaseUnityPlugin)this).Logger.LogDebug((object)("Removing extra keys " + string.Join(",", list) + "."));
					foreach (string item2 in list)
					{
						cached_localization.Remove(item2);
					}
				}
			}
			return cached_localization;
		}

		private string ReadEmbeddedResourceFile(string filename)
		{
			using Stream stream = typeof(ValhallEternal).Assembly.GetManifestResourceStream(filename);
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}
	}
}
namespace ValhallEternal.oaths
{
	internal static class DamageTaken
	{
		public static class PlayerOathOfDamageTaken
		{
			[HarmonyPatch(typeof(Character), "RPC_Damage")]
			public static class EnemyDamageScalingIncrease
			{
				public static void Prefix(Character __instance, ref HitData hit)
				{
					if (__instance.IsPlayer() && PlayerData.localPlayerConfig.TotalOaths.ContainsKey(DataObjects.Oaths.DamageTakenIncrease) && (Object)(object)((__instance is Player) ? __instance : null) == (Object)(object)Player.m_localPlayer)
					{
						float num = PlayerData.localPlayerConfig.TotalOaths[DataObjects.Oaths.DamageTakenIncrease] / 100f + 1f;
						Logger.LogDebug($"Oath of Damage Taken mult: {num} Hit total dmg: {hit.GetTotalDamage()}");
						((DamageTypes)(ref hit.m_damage)).Modify(num);
						Logger.LogDebug($"New Oath increased Damage: {hit.GetTotalDamage()}");
					}
				}
			}
		}
	}
	internal static class DealLessDamage
	{
		public static class PlayerOathOfReducedDamageDealt
		{
			[HarmonyPatch(typeof(Character), "RPC_Damage")]
			public static class EnemyDamageScalingIncrease
			{
				public static void Prefix(ref HitData hit)
				{
					Character attacker = hit.GetAttacker();
					if (!((Object)(object)attacker != (Object)null) || !attacker.IsPlayer() || !((Object)(object)((attacker is Player) ? attacker : null) == (Object)(object)Player.m_localPlayer) || !PlayerData.localPlayerConfig.DealReductedDamageActive)
					{
						return;
					}
					if (PlayerData.localPlayerConfig.HasOath(DataObjects.Oaths.DealLessAllDamage, out var OathValue))
					{
						float num = 1f - OathValue;
						if ((double)num < 0.2)
						{
							num = 0.2f;
						}
						((DamageTypes)(ref hit.m_damage)).Modify(num);
						Logger.LogDebug($"Reducing all damage done by {1f - num}");
					}
					if (PlayerData.localPlayerConfig.HasOath(DataObjects.Oaths.DealLessBluntDamage, out var OathValue2))
					{
						float num2 = 1f - OathValue2;
						if ((double)num2 < 0.2)
						{
							num2 = 0.2f;
						}
						hit.m_damage.m_blunt *= num2;
						Logger.LogDebug($"Reduced Blunt damage done by {1f - num2}");
					}
					if (PlayerData.localPlayerConfig.HasOath(DataObjects.Oaths.DealLessSlashDamage, out var OathValue3))
					{
						float num3 = 1f - OathValue3;
						hit.m_damage.m_slash *= num3;
						Logger.LogDebug($"Reduced Slash damage done by {1f - num3}.");
					}
					if (PlayerData.localPlayerConfig.HasOath(DataObjects.Oaths.DealLessPierceDamage, out var OathValue4))
					{
						float num4 = 1f - OathValue4;
						hit.m_damage.m_pierce *= num4;
						Logger.LogDebug($"Reduced Pierce damage done {1f - num4}.");
					}
				}
			}
		}
	}
	internal static class LowerSkillGains
	{
		public static class PlayerOathOfReducedDamageDealt
		{
			[HarmonyPatch(typeof(Player), "RaiseSkill")]
			public static class EnemyDamageScalingIncrease
			{
				public static void Prefix(Player __instance, SkillType skill, ref float value)
				{
					//IL_0023: Unknown result type (might be due to invalid IL or missing references)
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: 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_0027: Unknown result type (might be due to invalid IL or missing references)
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					//IL_0067: Expected I4, but got Unknown
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_006c: Invalid comparison between Unknown and I4
					//IL_0073: Unknown result type (might be due to invalid IL or missing references)
					//IL_0076: Invalid comparison between Unknown and I4
					if (!((Object)(object)__instance == (Object)(object)Player.m_localPlayer) || !PlayerData.localPlayerConfig.ReduceSkillGainsActive)
					{
						return;
					}
					switch (skill - 1)
					{
					case 2:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainClub, value);
						return;
					case 0:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainSword, value);
						return;
					case 1:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainKnives, value);
						return;
					case 3:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainPolearms, value);
						return;
					case 4:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainSpears, value);
						return;
					case 7:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainBow, value);
						return;
					case 13:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainCrossbow, value);
						return;
					case 9:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainBloodMagic, value);
						return;
					case 8:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainElementalMagic, value);
						return;
					case 6:
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainAxes, value);
						return;
					case 5:
					case 10:
					case 11:
					case 12:
						return;
					}
					if ((int)skill != 101)
					{
						if ((int)skill == 102)
						{
							value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainRun, value);
						}
					}
					else
					{
						value *= ModifySkillGain(DataObjects.Oaths.LowerSkillGainSneak, value);
					}
				}

				private static float ModifySkillGain(DataObjects.Oaths oathkey, float value)
				{
					if (PlayerData.localPlayerConfig.TotalOaths.ContainsKey(oathkey))
					{
						float num = 1f - PlayerData.localPlayerConfig.TotalOaths[oathkey];
						Logger.LogDebug($"Applied {oathkey} {value} * {num} -> {value * num}.");
						value *= num;
					}
					return value;
				}
			}
		}
	}
	internal static class ReduceCarryWeight
	{
		[HarmonyPatch(typeof(SEMan), "ModifyMaxCarryWeight")]
		public static class ReduceCarryWeightOath
		{
			public static void Postfix(SEMan __instance, ref float limit)
			{
				if (__instance.m_character.IsPlayer() && PlayerData.localPlayerConfig.HasOath(DataObjects.Oaths.ReducePlayerCarryWeight, out var OathValue))
				{
					limit -= OathValue;
				}
			}
		}
	}
	internal static class ReducePlayerHealthPercent
	{
		[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
		public static class ReducePlayerHealthStaminaEitrPercent
		{
			public static void Postfix(ref float stamina, ref float hp, ref float eitr)
			{
				if (PlayerData.localPlayerConfig.HasOath(DataObjects.Oaths.ReducePlayerHealthPercent, out var OathValue))
				{
					hp *= 1f - OathValue;
				}
				if (PlayerData.localPlayerConfig.HasOath(DataObjects.Oaths.ReducePlayerStaminaPercent, out var OathValue2))
				{
					stamina *= 1f - OathValue2;
				}
				if (PlayerData.localPlayerConfig.HasOath(DataObjects.Oaths.ReducePlayerEitrPercent, out var OathValue3))
				{
					eitr *= 1f - OathValue3;
				}
			}
		}
	}
}
namespace ValhallEternal.modules
{
	internal static class Commands
	{
		internal class SetPlayerEternalLevel : ConsoleCommand
		{
			public override string Name => "VE-Set-Player-Level";

			public override string Help => "Format: [level]";

			public override void Run(string[] args)
			{
				if (args.Length < 1)
				{
					Logger.LogInfo("Level required.");
				}
				int.TryParse(args[0].Trim(), out var result);
				if (result != 0)
				{
					Logger.LogDebug($"Setting player prestige level {result}");
					((Character)Player.m_localPlayer).m_nview.GetZDO().Set(DataObjects.CustomLevelZKey, result);
					Player.m_localPlayer.PlayerRemoveUniqueKey(DataObjects.CustomLevelZKey);
					Player.m_localPlayer.AddUniqueKeyValue(DataObjects.CustomLevelZKey, $"{result}");
					PrestigeDisplays.UpdateLocalPlayerLevelDisplay();
				}
			}
		}

		internal class ClearPlayerData : ConsoleCommand
		{
			public override string Name => "VE-remove-player-data";

			public override string Help => "This clears ALL boon, oath, prestige, and player levels. REQUIRES A CLIENT RESTART";

			public override bool IsCheat => true;

			public override void Run(string[] args)
			{
				Player.m_localPlayer.m_customData.Remove(DataObjects.CustomDataKey);
			}
		}

		internal static void AddCommands()
		{
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new SetPlayerEternalLevel());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ClearPlayerData());
		}
	}
	internal static class Compendium
	{
		[HarmonyPatch(typeof(TextsDialog), "UpdateTextsList")]
		public static class TextsDialog_UpdateTextsList_Patch
		{
			public static void Postfix(TextsDialog __instance)
			{
				diagTexts = __instance;
				AddDietyPrestigeExplanations(__instance);
			}

			private static void AddDietyPrestigeExplanations(TextsDialog textsDialog)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Expected O, but got Unknown
				string text = BuildPrestigeOathBoonCompendiumEntry();
				string text2 = Localization.instance.Localize("$ve_compendium_name");
				if (textsDialog.m_texts[0].m_topic != text2)
				{
					textsDialog.m_texts.Insert(0, new TextInfo(text2, text));
				}
			}
		}

		private static readonly string HeaderColor = "#ffa64d";

		private static readonly string BoonColor = "#40B850";

		private static readonly string OathColor = "#CF2713";

		private static TextsDialog diagTexts;

		internal static void UpdateDietyPrestigeExplanations()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			if (!((Object)(object)diagTexts == (Object)null))
			{
				string compendiumTopic = Localization.instance.Localize("$ve_compendium_name");
				int num = diagTexts.m_texts.FindIndex((TextInfo t) => t.m_topic == compendiumTopic);
				if (num >= 0)
				{
					string text = BuildPrestigeOathBoonCompendiumEntry();
					diagTexts.m_texts[num] = new TextInfo(compendiumTopic, text);
				}
			}
		}

		private static string BuildPrestigeOathBoonCompendiumEntry()
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (PlayerData.localPlayerConfig.TotalBoons.Count > 0)
			{
				stringBuilder.AppendLine("<color=" + HeaderColor + ">" + Localization.instance.Localize("$ve_boon_section_header") + "</color>");
				stringBuilder.AppendLine();
			}
			foreach (KeyValuePair<DataObjects.Boons, float> totalBoon in PlayerData.localPlayerConfig.TotalBoons)
			{
				stringBuilder.AppendLine(Localization.instance.Localize($"{DataObjects.LocalizeBoon(totalBoon.Key)} ($ve_level <color={BoonColor}>{totalBoon.Value}</color>) - {DataObjects.LocalizeBoonDesc(totalBoon.Key)}"));
			}
			if (stringBuilder.Length > 0)
			{
				stringBuilder.AppendLine();
			}
			if (PlayerData.localPlayerConfig.TotalOaths.Count > 0)
			{
				stringBuilder.AppendLine("<color=" + HeaderColor + ">" + Localization.instance.Localize("$ve_oath_section_header") + "</color>");
				stringBuilder.AppendLine();
			}
			foreach (KeyValuePair<DataObjects.Oaths, float> totalOath in PlayerData.localPlayerConfig.TotalOaths)
			{
				stringBuilder.AppendLine(Localization.instance.Localize($"{DataObjects.LocalizeOath(totalOath.Key)} ($ve_level <color={OathColor}>{totalOath.Value}</color>) - {DataObjects.LocalizeOathDesc(totalOath.Key, totalOath.Value)}"));
			}
			Logger.LogDebug($"Built compendium entry:\n{stringBuilder}");
			return Localization.instance.Localize(stringBuilder.ToString());
		}
	}
	internal static class Locations
	{
		public static void SetupLocations()
		{
			AddLocationsToWorldGen((Biome)1, "ve_tribute_gefjun", ValConfig.MaxMeadowsLocations.Value);
			AddLocationsToWorldGen((Biome)8, "ve_tribute_vor", ValConfig.MaxBlackForestLocations.Value);
			AddLocationsToWorldGen((Biome)2, "ve_tribute_baldur", ValConfig.MaxSwampLocations.Value);
			AddLocationsToWorldGen((Biome)4, "ve_tribute_skaldi", ValConfig.MaxMountainLocations.Value);
			AddLocationsToWorldGen((Biome)16, "ve_tribute_syn", ValConfig.MaxPlainsLocations.Value);
			AddLocationsToWorldGen((Biome)512, "ve_tribute_freya", ValConfig.MaxMistlandsLocations.Value);
			AddLocationsToWorldGen((Biome)32, "ve_tribute_hel", ValConfig.MaxAshlandsLocations.Value);
		}

		public static void AddLocationsToWorldGen(Biome targetBiome, string prefabname, int maxLocationAmount = 10)
		{
			//IL_002d: 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_004a: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			GameObject val = ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/locations/" + prefabname + ".prefab");
			GameObject val2 = ZoneManager.Instance.CreateLocationContainer(val);
			Logger.LogInfo($"Tribute generation: {targetBiome} location {((Object)val2).name}");
			LocationConfig val3 = new LocationConfig();
			val3.Biome = targetBiome;
			val3.Quantity = maxLocationAmount;
			val3.Priotized = true;
			val3.ExteriorRadius = 5f;
			val3.SlopeRotation = true;
			val3.MinAltitude = 1f;
			val3.ClearArea = false;
			val3.RandomRotation = true;
			val3.MinDistanceFromSimilar = ValConfig.MinDistanceBetweenTributeLocations.Value;
			ZoneManager.Instance.AddCustomLocation(new CustomLocation(val2, true, val3));
		}
	}
	internal class OathUI : MonoBehaviour
	{
		private static OathUI _instance;

		private static GameObject OathPanel;

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

		public void Awake()
		{
		}

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

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

		private void CreateStaticUIObjects()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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)
			if (GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				Logger.LogWarning("GUIManager not setup, skipping static object creation.");
				return;
			}
			OathPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 800f, 800f, true);
			OathPanel.SetActive(false);
			GameObject val = GUIManager.Instance.CreateText(Localization.instance.Localize("$selection_header"), OathPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(50f, 360f), GUIManager.Instance.AveriaSerifBold, 30, GUIManager.Instance.ValheimOrange, true, Color.black, 350f, 40f, false);
			((Object)val).name = "DLHeader";
		}
	}
	public static class PlayerData
	{
		[HarmonyPatch(typeof(Player))]
		public static class LoadPlayerBoonOaths
		{
			[HarmonyPostfix]
			[HarmonyPatch("Load")]
			private static void Postfix(Player __instance)
			{
				LoadPlayerConfiguration(__instance);
			}
		}

		public static DataObjects.CompositePlayerConfig localPlayerConfig = new DataObjects.CompositePlayerConfig();

		public static void SetPlayerConfig(DataObjects.PlayerLevelData pld)
		{
			Dictionary<DataObjects.Oaths, float> dictionary = new Dictionary<DataObjects.Oaths, float>();
			Dictionary<DataObjects.Boons, float> dictionary2 = new Dictionary<DataObjects.Boons, float>();
			if (pld.PlayerOaths != null)
			{
				foreach (KeyValuePair<DataObjects.Oaths, float> playerOath in pld.PlayerOaths)
				{
					if (dictionary.ContainsKey(playerOath.Key))
					{
						dictionary[playerOath.Key] += playerOath.Value;
					}
					else
					{
						dictionary.Add(playerOath.Key, playerOath.Value);
					}
				}
			}
			if (pld.PlayerBoons != null)
			{
				foreach (KeyValuePair<DataObjects.Boons, float> playerBoon in pld.PlayerBoons)
				{
					if (dictionary2.ContainsKey(playerBoon.Key))
					{
						dictionary2[playerBoon.Key] += playerBoon.Value;
					}
					else
					{
						dictionary2.Add(playerBoon.Key, playerBoon.Value);
					}
				}
			}
			bool dealReductedDamageActive = false;
			foreach (DataObjects.Oaths damageReductionOath in DataObjects.DamageReductionOaths)
			{
				if (dictionary.ContainsKey(damageReductionOath))
				{
					dealReductedDamageActive = true;
					break;
				}
			}
			bool reduceSkillGainsActive = false;
			foreach (DataObjects.Oaths reducedSkillGainOath in DataObjects.ReducedSkillGainOaths)
			{
				if (dictionary.ContainsKey(reducedSkillGainOath))
				{
					reduceSkillGainsActive = true;
					break;
				}
			}
			localPlayerConfig = new DataObjects.CompositePlayerConfig
			{
				ReduceSkillGainsActive = reduceSkillGainsActive,
				DealReductedDamageActive = dealReductedDamageActive,
				TotalOaths = dictionary,
				TotalBoons = dictionary2,
				ActiveEffectsForPlayer = pld.ActiveEffectsForPlayer,
				AvailableEffectsForPlayer = pld.AvailableEffectsForPlayer
			};
			if (localPlayerConfig.AvailableEffectsForPlayer != null)
			{
				foreach (KeyValuePair<DataObjects.PrestigeEffect, List<string>> item in localPlayerConfig.AvailableEffectsForPlayer)
				{
					if (!item.Value.Contains(DataObjects.None))
					{
						item.Value.Insert(0, DataObjects.None);
					}
				}
			}
			if (pld != null)
			{
				Logger.LogDebug($"Player Presitge Level: {pld.PlayerLevel}");
				localPlayerConfig.PlayerLevel = pld.PlayerLevel;
			}
			Logger.LogDebug($"Set player config: Oaths-{localPlayerConfig.TotalOaths.Count}, Boons-{localPlayerConfig.TotalBoons.Count}");
			foreach (KeyValuePair<DataObjects.Oaths, float> totalOath in localPlayerConfig.TotalOaths)
			{
				Logger.LogDebug($" - Oath: {totalOath.Key} Value: {totalOath.Value}");
			}
			foreach (KeyValuePair<DataObjects.Boons, float> totalBoon in localPlayerConfig.TotalBoons)
			{
				Logger.LogDebug($" - Boon: {totalBoon.Key} Value: {totalBoon.Value}");
			}
		}

		public static bool HasBoon(DataObjects.Boons boon)
		{
			if (localPlayerConfig.TotalBoons == null)
			{
				return false;
			}
			if (localPlayerConfig.TotalBoons.Keys.Contains(boon))
			{
				return true;
			}
			return false;
		}

		public static bool HasBoonWithValue(DataObjects.Boons boon, out float value)
		{
			value = 0f;
			if (localPlayerConfig.TotalBoons == null)
			{
				return false;
			}
			if (localPlayerConfig.TotalBoons.Keys.Contains(boon))
			{
				value = localPlayerConfig.TotalBoons[boon];
				return true;
			}
			return false;
		}

		public static bool HasOathWithValue(DataObjects.Oaths oath, out float value)
		{
			value = 0f;
			if (localPlayerConfig.TotalOaths == null)
			{
				return false;
			}
			if (localPlayerConfig.TotalOaths.Keys.Contains(oath))
			{
				value = localPlayerConfig.TotalOaths[oath];
				return true;
			}
			return false;
		}

		public static void AddOathToPlayerConfig(DataObjects.Oaths oath, float value)
		{
			if (localPlayerConfig.TotalOaths.ContainsKey(oath))
			{
				localPlayerConfig.TotalOaths[oath] += value;
			}
			else
			{
				localPlayerConfig.TotalOaths.Add(oath, value);
			}
		}

		public static void AddBoonToPlayerConfig(DataObjects.Boons boon, float value)
		{
			if (localPlayerConfig.TotalBoons.ContainsKey(boon))
			{
				localPlayerConfig.TotalBoons[boon] += value;
			}
			else
			{
				localPlayerConfig.TotalBoons.Add(boon, value);
			}
		}

		public static void AddVisualPrestigeEffectOptionToPlayerConfig(DataObjects.PrestigeEffect effectType, string effectKey)
		{
			if (localPlayerConfig.AvailableEffectsForPlayer != null)
			{
				if (localPlayerConfig.AvailableEffectsForPlayer.ContainsKey(effectType) && !localPlayerConfig.AvailableEffectsForPlayer[effectType].Contains(effectKey))
				{
					localPlayerConfig.AvailableEffectsForPlayer[effectType].Add(effectKey);
				}
				else if (!localPlayerConfig.AvailableEffectsForPlayer.ContainsKey(effectType))
				{
					localPlayerConfig.AvailableEffectsForPlayer[effectType] = new List<string> { effectKey };
				}
			}
			else
			{
				localPlayerConfig.AvailableEffectsForPlayer = new Dictionary<DataObjects.PrestigeEffect, List<string>> { 
				{
					effectType,
					new List<string>
					{
						DataObjects.None,
						effectKey
					}
				} };
			}
		}

		public static void SetActivePrestigeEffectForPlayer(DataObjects.PrestigeEffect effectType, string effectKey)
		{
			if (localPlayerConfig.ActiveEffectsForPlayer != null)
			{
				if (localPlayerConfig.ActiveEffectsForPlayer.ContainsKey(effectType))
				{
					localPlayerConfig.ActiveEffectsForPlayer[effectType] = effectKey;
				}
				else
				{
					localPlayerConfig.ActiveEffectsForPlayer.Add(effectType, effectKey);
				}
			}
			else
			{
				localPlayerConfig.ActiveEffectsForPlayer = new Dictionary<DataObjects.PrestigeEffect, string> { { effectType, effectKey } };
			}
		}

		public static bool PlayerHasAnyPrestigeEffect()
		{
			if (localPlayerConfig.AvailableEffectsForPlayer != null)
			{
				foreach (KeyValuePair<DataObjects.PrestigeEffect, List<string>> item in localPlayerConfig.AvailableEffectsForPlayer)
				{
					if (item.Value.Count > 1)
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool PlayerHasPrestigeEffect(DataObjects.PrestigeEffect type, string name)
		{
			if (localPlayerConfig.AvailableEffectsForPlayer != null && localPlayerConfig.AvailableEffectsForPlayer.ContainsKey(type) && !localPlayerConfig.AvailableEffectsForPlayer[type].Contains(name))
			{
				return true;
			}
			return false;
		}

		public static void SavePlayerConfiguration()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				Logger.LogWarning("Cannot save player configuration, local player is null.");
				return;
			}
			DataObjects.PlayerLevelData playerLevelData = new DataObjects.PlayerLevelData
			{
				PlayerLevel = localPlayerConfig.PlayerLevel,
				PlayerOaths = localPlayerConfig.TotalOaths,
				PlayerBoons = localPlayerConfig.TotalBoons,
				ActiveEffectsForPlayer = localPlayerConfig.ActiveEffectsForPlayer,
				AvailableEffectsForPlayer = localPlayerConfig.AvailableEffectsForPlayer
			};
			string value = PackPlayerDataToString(playerLevelData);
			if (Player.m_localPlayer.m_customData.ContainsKey(DataObjects.CustomDataKey))
			{
				Player.m_localPlayer.m_customData[DataObjects.CustomDataKey] = value;
			}
			else
			{
				Player.m_localPlayer.m_customData.Add(DataObjects.CustomDataKey, value);
			}
			((Character)Player.m_localPlayer).m_nview.GetZDO().Set(DataObjects.CustomLevelZKey, playerLevelData.PlayerLevel);
			WritePrestigeEffectsToZDO();
		}

		public static string PackActiveEffectsForZDO(Dictionary<DataObjects.PrestigeEffect, string> active)
		{
			if (active == null || active.Count == 0)
			{
				return "";
			}
			List<string> list = new List<string>(active.Count);
			foreach (KeyValuePair<DataObjects.PrestigeEffect, string> item in active)
			{
				if (!string.IsNullOrEmpty(item.Value) && !(item.Value == DataObjects.None))
				{
					list.Add($"{item.Key}={item.Value}");
				}
			}
			return string.Join("|", list);
		}

		public static Dictionary<DataObjects.PrestigeEffect, string> UnpackActiveEffectsFromZDO(string packed)
		{
			Dictionary<DataObjects.PrestigeEffect, string> dictionary = new Dictionary<DataObjects.PrestigeEffect, string>();
			if (string.IsNullOrEmpty(packed))
			{
				return dictionary;
			}
			string[] array = packed.Split(new char[1] { '|' });
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num > 0 && Enum.TryParse<DataObjects.PrestigeEffect>(text.Substring(0, num), out var result))
				{
					dictionary[result] = text.Substring(num + 1);
				}
			}
			return dictionary;
		}

		public static void WritePrestigeEffectsToZDO()
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)((Character)Player.m_localPlayer).m_nview == (Object)null))
			{
				ZDO zDO = ((Character)Player.m_localPlayer).m_nview.GetZDO();
				if (zDO != null)
				{
					DataObjects.PrestigeEffectsDictionaryZNetProperty prestigeEffectsDictionaryZNetProperty = new DataObjects.PrestigeEffectsDictionaryZNetProperty(DataObjects.CustomPrestigeFxZKey, ((Character)Player.m_localPlayer).m_nview, null);
					prestigeEffectsDictionaryZNetProperty.ForceSet(localPlayerConfig.ActiveEffectsForPlayer);
				}
			}
		}

		public static List<OptionData> ListPlayerAvailablePrestigeEffect(DataObjects.PrestigeEffect effect = DataObjects.PrestigeEffect.Wings)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			List<OptionData> list = new List<OptionData>();
			if (localPlayerConfig.AvailableEffectsForPlayer != null && localPlayerConfig.AvailableEffectsForPlayer.ContainsKey(effect))
			{
				foreach (string item in localPlayerConfig.AvailableEffectsForPlayer[effect])
				{
					list.Add(new OptionData(item));
				}
			}
			return list;
		}

		public static string GetActivePrestigeEffectForType(DataObjects.PrestigeEffect type = DataObjects.PrestigeEffect.Wings)
		{
			if (localPlayerConfig.ActiveEffectsForPlayer != null && localPlayerConfig.ActiveEffectsForPlayer.ContainsKey(type))
			{
				return localPlayerConfig.ActiveEffectsForPlayer[type];
			}
			return null;
		}

		public static void LoadPlayerConfiguration(Player player)
		{
			if (player.m_customData.ContainsKey(DataObjects.CustomDataKey))
			{
				Logger.LogDebug("Saved player data found, loading.");
				DataObjects.PlayerLevelData playerLevelData = UnpackPlayerData(player.m_customData[DataObjects.CustomDataKey]);
				SetPlayerConfig(playerLevelData);
				PrestigeDisplays.UpdateLocalPlayerLevelDisplay(playerLevelData.PlayerLevel);
				if (playerLevelData.PlayerLevel != 0 && ((Character)player).m_nview.GetZDO().GetInt(DataObjects.CustomLevelZKey, 0) == 0)
				{
					((Character)player).m_nview.GetZDO().Set(DataObjects.CustomLevelZKey, playerLevelData.PlayerLevel);
				}
				if (playerLevelData.ActiveEffectsForPlayer != null)
				{
					foreach (KeyValuePair<DataObjects.PrestigeEffect, string> item in playerLevelData.ActiveEffectsForPlayer)
					{
						Logger.LogDebug($"Setting up player {item.Key} display: {item.Value}");
						switch (item.Key)
						{
						case DataObjects.PrestigeEffect.Wings:
							PrestigeDisplays.SetupPlayerWingsDisplay(item.Value);
							break;
						case DataObjects.PrestigeEffect.Aura:
							PrestigeDisplays.SetupPlayerAuraDisplay(item.Value);
							break;
						}
					}
				}
				WritePrestigeEffectsToZDO();
				Compendium.UpdateDietyPrestigeExplanations();
			}
			else
			{
				Logger.LogDebug("No saved player saved data found.");
			}
		}

		public static string PackPlayerDataToString(DataObjects.PlayerLevelData playerData)
		{
			return DataObjects.yamlserializerJsonCompat.Serialize((object)playerData);
		}

		public static DataObjects.PlayerLevelData UnpackPlayerData(string packedPlayerData)
		{
			return DataObjects.yamldeserializer.Deserialize<DataObjects.PlayerLevelData>(packedPlayerData);
		}
	}
	public static class PrestigeAndCosmeticUI
	{
		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		public static class AddSacrificeUIButton
		{
			public static void Postfix(InventoryGui __instance)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				if (!((Object)(object)CosmeticsButton != (Object)null))
				{
					CosmeticsButton = GUIManager.Instance.CreateButton(Localization.instance.Localize("$ve_prestige_options"), ((Component)__instance.m_infoPanel).transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-628f, -90f), 90f, 60f);
					Button component = CosmeticsButton.GetComponent<Button>();
					((Selectable)component).interactable = true;
					CosmeticsButton.AddComponent<PrestigeUI>();
					((UnityEvent)component.onClick).AddListener(new UnityAction(PrestigeUI.Instance.Show));
					CosmeticsButton.SetActive(false);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		public static class HideSacrificeUI_InventoryClose
		{
			public static void Postfix()
			{
				PrestigeUI.Instance.Hide();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		public static class HideSacrificeUI_InventoryOpen
		{
			public static void Postfix()
			{
				if ((Object)(object)CosmeticsButton != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null && PlayerData.PlayerHasAnyPrestigeEffect())
				{
					CosmeticsButton.SetActive(true);
				}
			}
		}

		internal class PrestigeUI : MonoBehaviour
		{
			private static PrestigeUI _instance;

			private static GameObject PrestigePanel;

			private static GameObject WingSelectorDropdown;

			private static GameObject AuraSelectorDropdown;

			private static GameObject ManualCloseButton;

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

			public void Awake()
			{
				_instance = this;
			}

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

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

			public static void EnableDisablePrestigeSelctions()
			{
				if (PlayerData.localPlayerConfig.AvailableEffectsForPlayer != null)
				{
					Logger.LogDebug($"Enabling usable prestige options in UI: wings-{PlayerData.localPlayerConfig.AvailableEffectsForPlayer.ContainsKey(DataObjects.PrestigeEffect.Wings)} Aura-{PlayerData.localPlayerConfig.AvailableEffectsForPlayer.ContainsKey(DataObjects.PrestigeEffect.Aura)}.");
					bool active = PlayerData.localPlayerConfig.AvailableEffectsForPlayer.ContainsKey(DataObjects.PrestigeEffect.Wings) && PlayerData.localPlayerConfig.AvailableEffectsForPlayer[DataObjects.PrestigeEffect.Wings].Count > 1;
					WingSelectorDropdown.SetActive(active);
					bool active2 = PlayerData.localPlayerConfig.AvailableEffectsForPlayer.ContainsKey(DataObjects.PrestigeEffect.Aura) && PlayerData.localPlayerConfig.AvailableEffectsForPlayer[DataObjects.PrestigeEffect.Aura].Count > 1;
					AuraSelectorDropdown.SetActive(active2);
				}
			}

			private void CreateStaticUIObjects()
			{
				//IL_0048: 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_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Expected O, but got Unknown
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Expected O, but got Unknown
				//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_0214: Unknown result type (might be due to invalid IL or missing references)
				//IL_0250: Unknown result type (might be due to invalid IL or missing references)
				//IL_025a: Expected O, but got Unknown
				if (GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
				{
					Logger.LogWarning("GUIManager not setup, skipping static object creation.");
					return;
				}
				PrestigePanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 300f, 400f, true);
				PrestigePanel.SetActive(false);
				WingSelectorDropdown = GUIManager.Instance.CreateDropDown(PrestigePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 18, 200f, 40f);
				Dropdown component = WingSelectorDropdown.GetComponent<Dropdown>();
				component.AddOptions(PlayerData.ListPlayerAvailablePrestigeEffect());
				string activePrestigeEffectForType = PlayerData.GetActivePrestigeEffectForType();
				component.value = component.options.IndexOf(new OptionData(activePrestigeEffectForType));
				((UnityEvent<int>)(object)component.onValueChanged).AddListener((UnityAction<int>)UpdateSelectedWings);
				AuraSelectorDropdown = GUIManager.Instance.CreateDropDown(PrestigePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, -50f), 18, 200f, 40f);
				Dropdown component2 = AuraSelectorDropdown.GetComponent<Dropdown>();
				component2.AddOptions(PlayerData.ListPlayerAvailablePrestigeEffect(DataObjects.PrestigeEffect.Aura));
				string activePrestigeEffectForType2 = PlayerData.GetActivePrestigeEffectForType(DataObjects.PrestigeEffect.Aura);
				component2.value = component2.options.IndexOf(new OptionData(activePrestigeEffectForType2));
				((UnityEvent<int>)(object)component2.onValueChanged).AddListener((UnityAction<int>)UpdateSelectedAura);
				ManualCloseButton = GUIManager.Instance.CreateButton(Localization.instance.Localize("$ve_close"), PrestigePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(108f, 158f), 60f, 60f);
				Button component3 = ManualCloseButton.GetComponent<Button>();
				((Selectable)component3).interactable = true;
				((UnityEvent)component3.onClick).AddListener(new UnityAction(Hide));
			}

			public void UpdateSelectedWings(int _actionID)
			{
				Dropdown component = WingSelectorDropdown.GetComponent<Dropdown>();
				string text = component.options[component.value].text;
				Logger.LogDebug("Applying selected visual: " + text);
				PrestigeDisplays.SetupPlayerWingsDisplay(text);
				PlayerData.SetActivePrestigeEffectForPlayer(DataObjects.PrestigeEffect.Wings, text);
				PlayerData.SavePlayerConfiguration();
			}

			public void UpdateSelectedAura(int _actionID)
			{
				Dropdown component = AuraSelectorDropdown.GetComponent<Dropdown>();
				string text = component.options[component.value].text;
				Logger.LogDebug("Applying selected visual: " + text);
				PrestigeDisplays.SetupPlayerAuraDisplay(text);
				PlayerData.SetActivePrestigeEffectForPlayer(DataObjects.PrestigeEffect.Aura, text);
				PlayerData.SavePlayerConfiguration();
			}

			public void ApplySelectedEffects()
			{
				Dropdown component = WingSelectorDropdown.GetComponent<Dropdown>();
			}
		}

		private static GameObject CosmeticsButton;
	}
	internal static class PrestigeDisplays
	{
		public class PrestigeLevelHUD
		{
			public GameObject hudroot { get; set; }

			public GameObject root { get; set; }

			public TextMeshProUGUI tmpGUI { get; set; }
		}

		internal static class EnablePlayerPrestigeDisplays
		{
			[HarmonyPatch(typeof(Player), "Awake")]
			public static class EnableLocalPlayerPrestigeDisplays
			{
				public static void Postfix(Player __instance)
				{
					UpdateLocalPlayerLevelDisplay();
					foreach (KeyValuePair<DataObjects.PrestigeEffect, string> item in PlayerData.localPlayerConfig.ActiveEffectsForPlayer)
					{
						switch (item.Key)
						{
						case DataObjects.PrestigeEffect.Wings:
							SetupPlayerWingsDisplay(item.Value);
							break;
						case DataObjects.PrestigeEffect.Aura:
							SetupPlayerAuraDisplay(item.Value);
							break;
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(EnemyHud))]
		public static class SetupOtherPlayerLevelDisplay
		{
			[HarmonyPatch("ShowHud")]
			public static void Postfix(EnemyHud __instance, Character c)
			{
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)c == (Object)null || (Object)(object)__instance == (Object)null || !c.IsPlayer())
				{
					return;
				}
				HudData val = __instance.m_huds[c];
				if (val == null)
				{
					return;
				}
				Player val2 = (Player)(object)((c is Player) ? c : null);
				if ((Object)(object)val2 == (Object)null || (Object)(object)((Character)val2).m_nview == (Object)null || ((Character)val2).m_nview.GetZDO() == null)
				{
					return;
				}
				ZDO zDO = ((Character)val2).m_nview.GetZDO();
				ZDOID zDOID = ((Character)val2).GetZDOID();
				uint iD = ((ZDOID)(ref zDOID)).ID;
				int @int = zDO.GetInt(DataObjects.CustomLevelZKey, 0);
				Logger.LogDebug($"Player {val2.GetPlayerName()}-{iD} level {@int}");
				if (extendedPlayerHUDS.ContainsKey(iD))
				{
					if (@int == 0)
					{
						if ((Object)(object)extendedPlayerHUDS[iD].root != (Object)null)
						{
							extendedPlayerHUDS[iD].root.SetActive(false);
						}
					}
					else if ((Object)(object)extendedPlayerHUDS[iD].root != (Object)null)
					{
						extendedPlayerHUDS[iD].root.SetActive(true);
					}
					if ((Object)(object)extendedPlayerHUDS[iD].tmpGUI != (Object)null)
					{
						((TMP_Text)extendedPlayerHUDS[iD].tmpGUI).text = $"{@int}";
					}
				}
				else if (!((Object)(object)val.m_gui == (Object)null))
				{
					CreateEnemyHud(iD, val.m_gui.transform, @int);
				}
			}
		}

		[HarmonyPatch(typeof(EnemyHud))]
		private static class CleanupOtherPlayerHUDS
		{
			[HarmonyPatch("UpdateHuds")]
			private static void Postfix()
			{
				if (extendedPlayerHUDS.Count != 0)
				{
					extendedPlayerHUDS = extendedPlayerHUDS.Where((KeyValuePair<uint, PrestigeLevelHUD> x) => (Object)(object)x.Value.root != (Object)null).ToDictionary((KeyValuePair<uint, PrestigeLevelHUD> kvp) => kvp.Key, (KeyValuePair<uint, PrestigeLevelHUD> kvp) => kvp.Value);
				}
			}
		}

		internal class SpawnedPrestigeVisual
		{
			public string Name { get; set; }

			public GameObject Instance { get; set; }
		}

		[HarmonyPatch(typeof(VisEquipment), "UpdateVisuals")]
		public static class SyncPrestigeVisuals
		{
			private static readonly Dictionary<ZDOID, Dictionary<DataObjects.PrestigeEffect, SpawnedPrestigeVisual>> spawned = new Dictionary<ZDOID, Dictionary<DataObjects.PrestigeEffect, SpawnedPrestigeVisual>>();

			public static void Postfix(VisEquipment __instance)
			{
				//IL_0086: 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_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_nview == (Object)null)
				{
					return;
				}
				ZDO zDO = __instance.m_nview.GetZDO();
				if (zDO == null)
				{
					return;
				}
				Player component = ((Component)__instance).GetComponent<Player>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)component == (Object)(object)Player.m_localPlayer))
				{
					DataObjects.PrestigeEffectsDictionaryZNetProperty prestigeEffectsDictionaryZNetProperty = new DataObjects.PrestigeEffectsDictionaryZNetProperty(DataObjects.CustomPrestigeFxZKey, ((Character)component).m_nview, null);
					Dictionary<DataObjects.PrestigeEffect, string> desired = prestigeEffectsDictionaryZNetProperty.Get();
					ZDOID uid = zDO.m_uid;
					if (!spawned.TryGetValue(uid, out var value))
					{
						value = new Dictionary<DataObjects.PrestigeEffect, SpawnedPrestigeVisual>();
						spawned[uid] = value;
					}
					UpdateOtherPlayerVFX(component, value, DataObjects.PrestigeEffect.Wings, desired);
					UpdateOtherPlayerVFX(component, value, DataObjects.PrestigeEffect.Aura, desired);
				}
			}

			private static void UpdateOtherPlayerVFX(Player player, Dictionary<DataObjects.PrestigeEffect, SpawnedPrestigeVisual> perPlayer, DataObjects.PrestigeEffect fx, Dictionary<DataObjects.PrestigeEffect, string> desired)
			{
				desired.TryGetValue(fx, out var value);
				perPlayer.TryGetValue(fx, out var value2);
				if (value2 == null || !(value2.Name == value) || !((Object)(object)value2.Instance != (Object)null))
				{
					if (value2 != null && (Object)(object)value2.Instance != (Object)null)
					{
						Object.Destroy((Object)(object)value2.Instance);
					}
					if (string.IsNullOrEmpty(value) || value == DataObjects.None || !Deities.PrestigeEffects.TryGetValue(fx, out var value3) || !value3.TryGetValue(value, out var value4) || (Object)(object)value4.EffectObject == (Object)null)
					{
						perPlayer[fx] = new SpawnedPrestigeVisual
						{
							Name = null,
							Instance = null
						};
					}
					else
					{
						GameObject instance = Object.Instantiate<GameObject>(value4.EffectObject, ((Component)player).gameObject.transform);
						perPlayer[fx] = new SpawnedPrestigeVisual
						{
							Name = value,
							Instance = instance
						};
					}
				}
			}
		}

		private static GameObject localPlayerVEHUD = null;

		private static TextMeshProUGUI localPlayerLevelText = null;

		internal static GameObject localPlayerWings = null;

		internal static GameObject localPlayerAura = null;

		public static Dictionary<uint, PrestigeLevelHUD> extendedPlayerHUDS = new Dictionary<uint, PrestigeLevelHUD>();

		public static void CreateLocalHudElements(Transform targetTform)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)localPlayerVEHUD == (Object)null)
			{
				Logger.LogDebug("Creating Local Player Level Display HUD Elements.");
				GameObject val = ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("VELocalHud");
				localPlayerVEHUD = Object.Instantiate<GameObject>(val, targetTform);
				if ((Object)(object)Hud.m_instance != (Object)null)
				{
					Transform val2 = Hud.m_instance.m_rootObject.transform.Find("MiniMap/small");
					if ((Object)(object)val2 != (Object)null)
					{
						localPlayerVEHUD.transform.position = val2.position;
						localPlayerVEHUD.transform.localPosition = new Vector3(localPlayerVEHUD.transform.localPosition.x - 108f, localPlayerVEHUD.transform.localPosition.y - 10f);
					}
				}
			}
			if ((Object)(object)localPlayerVEHUD != (Object)null && (Object)(object)localPlayerLevelText == (Object)null)
			{
				Logger.LogDebug("Finding Level TextMeshPro component.");
				Transform val3 = localPlayerVEHUD.transform.Find("Level");
				if ((Object)(object)val3 != (Object)null)
				{
					localPlayerLevelText = ((Component)val3).GetComponent<TextMeshProUGUI>();
				}
				else
				{
					Logger.LogDebug("Could not find Level GO");
				}
			}
		}

		public static void UpdateLocalPlayerLevelDisplay(int level = 0)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name.Equals("main"))
			{
				if (level == 0)
				{
					level = PlayerData.localPlayerConfig.PlayerLevel;
				}
				CreateLocalHudElements(GUIManager.CustomGUIFront.transform);
				SetupLocalPlayerLevelDisplay(localPlayerVEHUD, level);
			}
		}

		public static void SetupPlayerWingsDisplay(string selectedWings = null)
		{
			if (selectedWings == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			if ((Object)(object)localPlayerWings != (Object)null)
			{
				Object.Destroy((Object)(object)localPlayerWings);
			}
			if (!(selectedWings == DataObjects.None))
			{
				if (Deities.PrestigeEffects[DataObjects.PrestigeEffect.Wings].ContainsKey(selectedWings))
				{
					localPlayerWings = Object.Instantiate<GameObject>(Deities.PrestigeEffects[DataObjects.PrestigeEffect.Wings][selectedWings].EffectObject, ((Component)Player.m_localPlayer).gameObject.transform);
				}
				else
				{
					Logger.LogWarning("Selected wings " + selectedWings + " not found in Deities.PrestigeEffects");
				}
			}
		}

		public static void SetupPlayerAuraDisplay(string selectedAura = null)
		{
			if (selectedAura == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			if ((Object)(object)localPlayerAura != (Object)null)
			{
				Object.Destroy((Object)(object)localPlayerAura);
			}
			if (!(selectedAura == DataObjects.None))
			{
				if (Deities.PrestigeEffects[DataObjects.PrestigeEffect.Aura].ContainsKey(selectedAura))
				{
					localPlayerAura = Object.Instantiate<GameObject>(Deities.PrestigeEffects[DataObjects.PrestigeEffect.Aura][selectedAura].EffectObject, ((Component)Player.m_localPlayer).gameObject.transform);
				}
				else
				{
					Logger.LogWarning("Selected Aura " + selectedAura + " not found in Deities.PrestigeEffects");
				}
			}
		}

		public static void CreateEnemyHud(uint otherplayerzid, Transform targetTform, int otherplayerlevel)
		{
			Logger.LogDebug("Creating Enemy Player Hud.");
			GameObject val = ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("VERemoteHud");
			GameObject val2 = Object.Instantiate<GameObject>(val, targetTform);
			((Object)val2).name = "VERemoteHud";
			Transform val3 = val2.transform.Find("Level");
			TextMeshProUGUI component = ((Component)val3).GetComponent<TextMeshProUGUI>();
			if (otherplayerlevel == 0)
			{
				val2.SetActive(false);
			}
			else
			{
				((TMP_Text)component).text = $"{otherplayerlevel}";
			}
			extendedPlayerHUDS.Add(otherplayerzid, new PrestigeLevelHUD
			{
				root = val2,
				tmpGUI = component,
				hudroot = ((Component)targetTform).gameObject
			});
		}

		public static void SetupLocalPlayerLevelDisplay(GameObject hugGUI, int levelnum)
		{
			if (levelnum == 0)
			{
				hugGUI.SetActive(false);
				return;
			}
			hugGUI.SetActive(true);
			if ((Object)(object)localPlayerLevelText != (Object)null)
			{
				((TMP_Text)localPlayerLevelText).text = $"{levelnum}";
			}
		}
	}
	public static class SacrificePatches
	{
		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		public static class AddSacrificeUIButton
		{
			public static void Postfix(InventoryGui __instance)
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Expected O, but got Unknown
				if ((Object)(object)SacrificeEnableButton != (Object)null)
				{
					if ((Object)(object)Player.m_localPlayer != (Object)null)
					{
						SacrificeEnableButton.SetActive(Player.m_localPlayer.NoCostCheat());
					}
					return;
				}
				SacrificeEnableButton = GUIManager.Instance.CreateButton(Localization.instance.Localize("$ve_sacrifice_button"), ((Component)__instance.m_infoPanel).transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-612f, -26f), 60f, 60f);
				Button component = SacrificeEnableButton.GetComponent<Button>();
				((Selectable)component).interactable = true;
				invGUISacrifice = SacrificeEnableButton.AddComponent<SacrificeUI>();
				((UnityEvent)component.onClick).AddListener(new UnityAction(invGUISacrifice.Show));
				SacrificeEnableButton.SetActive(false);
			}
		}

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

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		public static class HideSacrificeUI_InventoryOpen
		{
			public static void Postfix()
			{
				if ((Object)(object)SacrificeEnableButton != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null)
				{
					SacrificeEnableButton.SetActive(Player.m_localPlayer.NoCostCheat());
				}
			}
		}

		private static SacrificeUI invGUISacrifice;

		private static GameObject SacrificeEnableButton;
	}
	internal class SacrificeUI : MonoBehaviour, Hoverable, Interactable
	{
		private GameObject SacrificePanel;

		private GameObject ScrollAreaView;

		private GameObject ScrollContentArea;

		private ToggleGroup SacrificeChoiceGroup;

		private GameObject SacrificeChoiceContainer;

		private GameObject ChoiceSelectButton;

		private GameObject ManualCloseButton;

		private GameObject DeitySelectorDropdown;

		private Text DeityName;

		private Text DeityDescription;

		private Image DeityImage;

		private Text WarningText;

		private List<Toggle> SacrificeToggleOptions = new List<Toggle>();

		private string SelectedChoice = "none";

		private Deities.Deity SelectedDeity;

		public bool enableExclusiveDeityMode;

		public Deities.Deity ExclusiveDeity;

		public void Awake()
		{
		}

		public void Update()
		{
			if (!((Object)(object)SacrificePanel == (Object)null) && SacrificePanel.activeSelf && Input.GetKeyDown((KeyCode)27))
			{
				Hide();
				GUIManager.BlockInput(false);
			}
		}

		public void Show()
		{
			if ((Object)(object)SacrificePanel == (Object)null)
			{
				CreateStaticUIObjects();
				Deities.Deity choiceList = Deities.Deity.Gefjun;
				if (enableExclusiveDeityMode)
				{
					choiceList = ExclusiveDeity;
					DeitySelectorDropdown.SetActive(false);
				}
				SetChoiceList(choiceList);
			}
			GUIManager.BlockInput(true);
			SacrificePanel.SetActive(true);
		}

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

		public void Toggle()
		{
			if ((Object)(object)SacrificePanel != (Object)null)
			{
				if (SacrificePanel.activeSelf)
				{
					Hide();
				}
				else
				{
					Show();
				}
			}
			else
			{
				Show();
			}
		}

		public void UpdateSelectedDiety(int _actionID)
		{
			if (enableExclusiveDeityMode)
			{
				SetChoiceList(ExclusiveDeity);
				return;
			}
			Dropdown component = DeitySelectorDropdown.GetComponent<Dropdown>();
			Deities.Deity choiceList = (Deities.Deity)Enum.Parse(typeof(Deities.Deity), component.options[component.value].text);
			SetChoiceList(choiceList);
		}

		public void CompleteSacrifice()
		{
			//IL_06ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_058f: Unknown result type (might be due to invalid IL or missing references)
			//IL_059b: Unknown result type (might be due to invalid IL or missing references)
			if (SelectedChoice == "None")
			{
				Logger.LogWarning("No sacrifice choice selected.");
				return;
			}
			bool flag = true;
			Logger.LogInfo($"Completing sacrifice choice: {SelectedChoice} for deity {SelectedDeity}");
			DataObjects.Sacrifice sacrifice = SacrificeData.AllSacrifices[SelectedDeity][SelectedChoice];
			if (sacrifice.ItemRequirements != null)
			{
				Dictionary<string, int> itemTotalsByName = ((Humanoid)Player.m_localPlayer).m_inventory.GetItemTotalsByName();
				foreach (KeyValuePair<string, int> itemRequirement in sacrifice.ItemRequirements)
				{
					bool flag2 = itemTotalsByName.ContainsKey(itemRequirement.Key);
					Logger.LogDebug($"Checking for tribute {itemRequirement.Value} of item {itemRequirement.Key} - {flag2}");
					if (!flag2)
					{
						flag = false;
						Logger.LogDebug($"Player did not have {itemRequirement.Value} of item {itemRequirement.Key}");
						break;
					}
				}
			}
			if (sacrifice.PlayerKeyRequirements != null)
			{
				foreach (string playerKeyRequirement in sacrifice.PlayerKeyRequirements)
				{
					bool flag3 = (Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey(playerKeyRequirement);
					bool flag4 = Player.m_localPlayer.PlayerHasUniqueKey(playerKeyRequirement);
					Logger.LogDebug($"Checking key {playerKeyRequirement} from player - global:{flag3} unique:{flag4}");
					if (!flag3 && !flag4)
					{
						flag = false;
						Logger.LogDebug("Player did not have the required key: " + playerKeyRequirement);
						break;
					}
				}
			}
			if (!flag && !Player.m_localPlayer.NoCostCheat())
			{
				Logger.LogWarning("Player did not meet the requirements, canceling.");
				WarningText.text = "Requirements not met";
				return;
			}
			Logger.LogDebug("Player has met requirements.");
			if (sacrifice.ItemRequirements != null)
			{
				foreach (KeyValuePair<string, int> itemRequirement2 in sacrifice.ItemRequirements)
				{
					if (!((Humanoid)Player.m_localPlayer).GetInventory().RemoveItemByPrefab(itemRequirement2.Key, itemRequirement2.Value) && !Player.m_localPlayer.NoCostCheat())
					{
						Logger.LogWarning("Unable to remove all of the required items, are you trying to cheat the deity?");
						return;
					}
				}
			}
			if (sacrifice.PlayerKeyRequirements != null)
			{
				foreach (string playerKeyRequirement2 in sacrifice.PlayerKeyRequirements)
				{
					Logger.LogDebug("Removing key " + playerKeyRequirement2 + " from player progression.");
					if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey(playerKeyRequirement2))
					{
						ZoneSystem.instance.RemoveGlobalKey(playerKeyRequirement2);
					}
					Player.m_localPlayer.PlayerRemoveUniqueKey(playerKeyRequirement2);
					ProgressionCompat.TryRemovePrivateKey(playerKeyRequirement2);
				}
			}
			if (sacrifice.PlayerBoonsChanges != null)
			{
				foreach (KeyValuePair<DataObjects.Boons, float> playerBoonsChange in sacrifice.PlayerBoonsChanges)
				{
					Logger.LogDebug($"Changing player boon {playerBoonsChange.Key} by {playerBoonsChange.Value}.");
					PlayerData.AddBoonToPlayerConfig(playerBoonsChange.Key, playerBoonsChange.Value);
				}
			}
			if (sacrifice.PlayerOathChanges != null)
			{
				foreach (KeyValuePair<DataObjects.Oaths, float> playerOathChange in sacrifice.PlayerOathChanges)
				{
					Logger.LogDebug($"Changing player oath {playerOathChange.Key} by {playerOathChange.Value}.");
					PlayerData.AddOathToPlayerConfig(playerOathChange.Key, playerOathChange.Value);
				}
			}
			if (sacrifice.ResetPlayer != null)
			{
				if (sacrifice.ResetPlayer.ResetKnownRecipes)
				{
					Player.m_localPlayer.m_knownMaterial.Clear();
					Player.m_localPlayer.m_knownRecipes.Clear();
				}
				if (sacrifice.ResetPlayer.ResetSkillPercentage > 0f)
				{
					Player.m_localPlayer.m_skills.LowerAllSkills(sacrifice.ResetPlayer.ResetSkillPercentage);
				}
				if (sacrifice.ResetPlayer.PrestigeLevelsGained > 0)
				{
					PlayerData.localPlayerConfig.PlayerLevel += sacrifice.ResetPlayer.PrestigeLevelsGained;
				}
				if (sacrifice.ResetPlayer.TeleportToSpawn)
				{
					GameObject val = (from obj in Resources.FindObjectsOfTypeAll<GameObject>()
						where ((Object)obj).name == "StartTemple"
						select obj).FirstOrDefault();
					if ((Object)(object)val != (Object)null)
					{
						Logger.LogDebug("Teleporting player to start temple.");
						((Character)Player.m_localPlayer).TeleportTo(val.transform.position, val.transform.rotation, false);
					}
					else
					{
						Logger.LogWarning("Start temple not found, teleporting to spawn point instead.");
						Vector3 val2 = default(Vector3);
						bool flag5 = default(bool);
						Game.instance.FindSpawnPoint(ref val2, ref flag5, 0f);
						((Character)Player.m_localPlayer).TeleportTo(val2, Quaternion.identity, true);
					}
				}
			}
			if (sacrifice.PrestigeOptions != null)
			{
				foreach (DataObjects.PrestigeEffectDetails prestigeOption in sacrifice.PrestigeOptions)
				{
					if (prestigeOption.PlayerMeetsPrestigeRequirements())
					{
						PlayerData.AddVisualPrestigeEffectOptionToPlayerConfig(prestigeOption.EffectType, prestigeOption.EffectValue);
						Logger.LogDebug($"Adding prestige effect option {prestigeOption.EffectType} of type {prestigeOption.EffectValue} to player config.");
						PlayerData.SetActivePrestigeEffectForPlayer(prestigeOption.EffectType, prestigeOption.EffectValue);
					}
				}
			}
			WarningText.text = "";
			GUIManager.BlockInput(false);
			PlayerData.SavePlayerConfiguration();
			PlayerData.LoadPlayerConfiguration(Player.m_localPlayer);
			PrestigeDisplays.UpdateLocalPlayerLevelDisplay();
			Hide();
			((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize("$ve_sacrifice_success"), 0, (Sprite)null);
			Object.Instantiate<GameObject>(DataObjects.BoonGrantedVFX, ((Component)Player.m_localPlayer).transform.position, Quaternion.identity);
			UpdateSelectedDiety(-1);
			if (enableExclusiveDeityMode)
			{
				SetChoiceList(SelectedDeity);
			}
		}

		private void CreateStaticUIObjects()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: 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_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Expected O, but got Unknown
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0518: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Expected O, but got Unknown
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0570: Unknown result type (might be due to invalid IL or missing references)
			//IL_058e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0683: Expected O, but got Unknown
			//IL_0740: Unknown result type (might be due to invalid IL or missing references)
			//IL_0755: Expected O, but got Unknown
			//IL_07d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_089f: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ae: 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_08d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_090e: Unknown result type (might be due to invalid IL or missing references)
			//IL_095b: Unknown result type (might be due to invalid IL or missing references)
			//IL_096a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0979: Unknown result type (might be due to invalid IL or missing references)
			//IL_098f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0995: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a12: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a21: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a30: 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)
			//IL_0a47: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aaa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abf: Expected O, but got Unknown
			//IL_0ae4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b34: Expected O, but got Unknown
			//IL_0ba4: Unknown result type (might be due to invalid IL or missing references)
			if (GUIManager.Instance == null || !Object.op_Implicit((Object)(object)GUIManager.CustomGUIFront))
			{
				Logger.LogWarning("GUIManager not setup, skipping static object creation.");
				return;
			}
			SacrificePanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 800f, 800f, true);
			SacrificePanel.SetActive(false);
			GameObject val = Object.Instantiate<GameObject>(new GameObject("DeityImage"), SacrificePanel.transform);
			val.transform.localPosition = new Vector3(-323f, 323f);
			DeityImage = val.AddComponent<Image>();
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(125f, 125f);
			DeityImage.sprite = Deities.DeityConfiguration[Deities.Deity.Gefjun].Image;
			GameObject val2 = GUIManager.Instance.CreateText(Localization.instance.Localize("$ve_header_gefjun"), SacrificePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(11f, 360f), GUIManager.Instance.AveriaSerifBold, 20, GUIManager.Instance.ValheimYellow, true, Color.black, 350f, 40f, false);
			DeityName = val2.GetComponent<Text>();
			((Object)DeityName).name = "DeityName";
			GameObject val3 = GUIManager.Instance.CreateText(Localization.instance.Localize("$ve_description_gefjun"), SacrificePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-110f, 325f), GUIManager.Instance.AveriaSerif, 14, Color.white, true, Color.black, 300f, 80f, false);
			DeityDescription = val3.GetComponent<Text>();
			DeityDescription.resizeTextForBestFit = true;
			DeityDescription.resizeTextMaxSize = 20;
			DeityDescription.alignment = (TextAnchor)4;
			((Object)DeityDescription).name = "DeityDesc";
			GameObject val4 = GUIManager.Instance.CreateText(Localization.instance.Localize("$ve_sacrifice_header"), SacrificePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(275f, 305f), GUIManager.Instance.AveriaSerifBold, 30, GUIManager.Instance.ValheimOrange, true, Color.black, 350f, 40f, false);
			((Object)val4).name = "Sacrifice";
			GameObject val5 = GUIManager.Instance.CreateText(Localization.instance.Localize("$ve_sacrifice_header_desc"), SacrificePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(6f, 217f), GUIManager.Instance.AveriaSerif, 20, Color.white, true, Color.black, 730f, 80f, false);
			((Object)val5).name = "SacrificeDesc";
			Text component = val5.GetComponent<Text>();
			component.resizeTextForBestFit = true;
			component.resizeTextMaxSize = 20;
			component.alignment = (TextAnchor)0;
			GameObject val6 = GUIManager.Instance.CreateText("", SacrificePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(335f, -350f), GUIManager.Instance.AveriaSerifBold, 14, GUIManager.Instance.ValheimYellow, true, Color.black, 250f, 40f, false);
			((Object)val6).name = "Warning";
			WarningText = val6.GetComponent<Text>();
			ManualCloseButton = GUIManager.Instance.CreateButton(Localization.instance.Localize("$ve_close"), SacrificePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(360f, 360f), 60f, 60f);
			Button component2 = ManualCloseButton.GetComponent<Button>();
			((Selectable)component2).interactable = true;
			((UnityEvent)component2.onClick).AddListener(new UnityAction(Hide));
			ChoiceSelectButton = GUIManager.Instance.CreateButton(Localization.instance.Localize("$ve_sacrifice_sealed"), SacrificePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, -350f), 300f, 60f);
			Button component3 = ChoiceSelectButton.GetComponent<Button>();
			((UnityEvent)component3.onClick).AddListener(new UnityAction(CompleteSacrifice));
			ScrollAreaView = GUIManager.Instance.CreateScrollView(SacrificePanel.transform, false, true, 10f, 10f, GUIManager.Instance.ValheimScrollbarHandleColorBlock, Color.grey, 750f, 500f);
			ScrollAreaView.transform.localPosition = Vector2.op_Implicit(new Vector2
			{
				x = 0f,
				y = -68f
			});
			ScrollAreaView.GetComponentInChildren<ScrollRect>().scrollSensitivity = 1000f;
			ScrollContentArea = ((Component)ScrollAreaView.GetComponentInChildren<ContentSizeFitter>()).gameObject;
			SacrificeChoiceGroup = ScrollContentArea.AddComponent<ToggleGroup>();
			DeitySelectorDropdown = GUIManager.Instance.CreateDropDown(SacrificePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(200f, 357f), 18, 200f, 40f);
			Dropdown component4 = DeitySelectorDropdown.GetComponent<Dropdown>();
			component4.AddOptions(Deities.DeityOptions());
			component4.value = 2;
			((UnityEvent<int>)(object)component4.onValueChanged).AddListener((UnityAction<int>)UpdateSelectedDiety);
			SacrificeChoiceContainer = Object.Instantiate<GameObject>(new GameObject("ChoiceTemplate"), SacrificePanel.transform);
			VerticalLayoutGroup val7 = SacrificeChoiceContainer.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val7).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val7).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val7).spacing = 5f;
			((HorizontalOrVerticalLayoutGroup)val7).childForceExpandHeight = false;
			if ((Object)(object)SacrificeChoiceContainer.GetComponent<RectTransform>() == (Object)null)
			{
				SacrificeChoiceContainer.AddComponent<RectTransform>();
			}
			SacrificeChoiceContainer.layer = 5;
			RectTransform component5 = SacrificeChoiceContainer.GetComponent<RectTransform>();
			component5.SetSizeWithCurrentAnchors((Axis)0, 760f);
			component5.SetSizeWithCurrentAnchors((Axis)1, 300f);
			ContentSizeFitter val8 = SacrificeChoiceContainer.AddComponent<ContentSizeFitter>();
			val8.verticalFit = (FitMode)2;
			SacrificeChoiceContainer.SetActive(false);
			GameObject val9 = Object.Instantiate<GameObject>(new GameObject("ChoiceHeader"), SacrificeChoiceContainer.transform);
			((Object)val9).name = "ChoiceHeader";
			HorizontalLayoutGroup val10 = val9.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val10).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val10).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val10).childControlWidth = true;
			LayoutElement val11 = val9.AddComponent<LayoutElement>();
			val11.minHeight = 40f;
			GameObject val12 = GUIManager.Instance.CreateToggle(val9.transform, 40f, 40f);
			((Object)val12).name = "selecter";
			val12.transform.localPosition = new Vector3(-370f, 10f);
			((Component)val12.transform.Find("Label")).gameObject.SetActive(false);
			val12.GetComponent<Toggle>().isOn = false;
			LayoutElement val13 = val12.AddComponent<LayoutElement>();
			val13.minWidth = 45f;
			HorizontalLayoutGroup val14 = val12.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val14).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val14).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val14).childControlWidth = true;
			GameObject gameObject = ((Component)val12.transform.Find("Background")).gameObject;
			LayoutElement val15 = gameObject.AddComponent<LayoutElement>();
			val15.minHeight = 40f;
			val15.minWidth = 40f;
			GameObject val16 = GUIManager.Instance.CreateText("Name", val9.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), GUIManager.Instance.AveriaSerifBold, 30, GUIManager.Instance.ValheimOrange, true, Color.black, 660f, 80f, false);
			((Object)val16).name = "ChoiceName";
			val16.transform.localPosition = new Vector3(-240f, -10f);
			LayoutElement val17 = val16.AddComponent<LayoutElement>();
			val17.flexibleHeight = 900f;
			val17.minHeight = 40f;
			GameObject val18 = GUIManager.Instance.CreateText("Desc", SacrificeChoiceContainer.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(16f, 40f), GUIManager.Instance.AveriaSerif, 20, GUIManager.Instance.ValheimBeige, true, Color.black, 660f, 80f, false);
			((Object)val18).name = "ChoiceDesc";
			LayoutElement val19 = val18.AddComponent<LayoutElement>();
			val19.flexibleHeight = 900f;
			VerticalLayoutGroup val20 = val18.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val20).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val20).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val20).childControlWidth = true;
			GameObject val21 = GUIManager.Instance.CreateText("Description", SacrificeChoiceContainer.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(16f, -40f), GUIManager.Instance.AveriaSerif, 20, Color.white, true, Color.black, 660f, 80f, false);
			((Object)val21).name = "RequirementDesc";
			LayoutElement val22 = val21.AddComponent<LayoutElement>();
			val22.flexibleHeight = 900f;
			VerticalLayoutGroup val23 = val21.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val23).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val23).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val23).childControlWidth = true;
			GameObject val24 = Object.Instantiate<GameObject>(new GameObject("ItemRequirements"), SacrificeChoiceContainer.transform);
			((Object)val24).name = "ItemRequirements";
			val24.transform.localPosition = new Vector3(-300f, 30f, 0f);
			val24.AddComponent<RectTransform>();
			val24.AddComponent<LayoutElement>();
			HorizontalLayoutGroup val25 = val24.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val25).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val25).childForceExpandWidth = false;
			GameObject val26 = Object.Instantiate<GameObject>(new GameObject("ChoiceFooter"), SacrificeChoiceContainer.transform);
			((Object)val26).name = "ChoiceFooter";
			LayoutElement val27 = val26.AddComponent<LayoutElement>();
			val27.minHeight = 50f;
			VerticalLayoutGroup val28 = val26.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val28).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val28).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val28).childControlWidth = true;
			Image val29 = val26.AddComponent<Image>();
			val29.sprite = DataObjects.boonbackground;
			((Component)val29).GetComponent<RectTransform>().sizeDelta = new Vector2(512f, 50f);
		}

		private void SetChoiceList(Deities.Deity selectedDiety)
		{
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_056e: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Expected O, but got Unknown
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_060e: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_062e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0634: Unknown result type (might be due to invalid IL or missing references)
			//IL_067d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			DeityName.text = Localization.instance.Localize(Deities.DeityConfiguration[selectedDiety].NameLocalKey);
			DeityDescription.text = Localization.instance.Localize(Deities.DeityConfiguration[selectedDiety].DescriptionLocalKey);
			DeityImage.sprite = Deities.DeityConfiguration[selectedDiety].Image;
			SacrificeToggleOptions.Clear();
			while (ScrollContentArea.transform.childCount > 0)
			{
				Transform child = ScrollContentArea.transform.GetChild(0);
				if ((Object)(object)child == (Object)null)
				{
					break;
				}
				Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
			}
			SelectedDeity = selectedDiety;
			int num = -40;
			ItemDrop val3 = default(ItemDrop);
			foreach (KeyValuePair<string, DataObjects.Sacrifice> entry in SacrificeData.AllSacrifices[selectedDiety])
			{
				bool flag = true;
				bool flag2 = true;
				bool flag3 = true;
				bool flag4 = true;
				if ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)ZoneSystem.instance != (Object)null)
				{
					if (entry.Value.PlayerKeyRequirements != null)
					{
						foreach (string playerKeyRequirement in entry.Value.PlayerKeyRequirements)
						{
							if (!ZoneSystem.instance.GetGlobalKey(playerKeyRequirement) && !Player.m_localPlayer.PlayerHasUniqueKey(playerKeyRequirement))
							{
								flag = false;
								break;
							}
						}
					}
					float BoonValue;
					if (entry.Value.PlayerBoonRequirements != null)
					{
						foreach (KeyValuePair<DataObjects.Boons, float> playerBoonRequirement in entry.Value.PlayerBoonRequirements)
						{
							if (!PlayerData.localPlayerConfig.HasBoon(playerBoonRequirement.Key, out BoonValue))
							{
								flag2 = false;
								break;
							}
						}
					}
					if (entry.Value.PlayerOathRequirements != null)
					{
						foreach (KeyValuePair<DataObjects.Oaths, float> playerOathRequirement in entry.Value.PlayerOathRequirements)
						{
							if (!PlayerData.localPlayerConfig.HasOath(playerOathRequirement.Key, out BoonValue))
							{
								flag3 = false;
								break;
							}
						}
					}
					if (entry.Value.PlayerBoonLimit != null)
					{
						foreach (KeyValuePair<DataObjects.Boons, float> item in entry.Value.PlayerBoonLimit)
						{
							if (PlayerData.localPlayerConfig.HasBoon(item.Key, out var BoonValue2) && BoonValue2 >= item.Value)
							{
								flag4 = false;
								break;
							}
						}
					}
				}
				if ((!flag && ValConfig.KeyRequirementsHideChoices.Value) || (!flag2 && ValConfig.BoonRequirementsHideChoices.Value) || (!flag3 && ValConfig.OathRequirementsHideChoices.Value) || !flag4)
				{
					continue;
				}
				GameObject val = Object.Instantiate<GameObject>(SacrificeChoiceContainer, ScrollContentArea.transform);
				val.SetActive(true);
				RectTransform component = val.GetComponent<RectTransform>();
				((Transform)component).localPosition = new Vector3
				{
					x = 250f,
					y = num
				};
				((Component)val.transform.Find("ChoiceHeader/ChoiceName")).GetComponent<Text>().text = entry.Value.Name;
				((Object)val).name = "choice_" + entry.Value.Name;
				((Component)val.transform.Find("ChoiceDesc")).GetComponent<Text>().text = entry.Value.Description;
				((Component)val.transform.Find("RequirementDesc")).GetComponent<Text>().text = entry.Value.GetTotalDescription();
				if (entry.Value.ItemRequirements != null)
				{
					Transform val2 = val.transform.Find("ItemRequirements");
					if ((Object)(object)val2 == (Object)null)
					{
						Logger.LogWarning("Item requirements parent not found.");
					}
					int num2 = 0;
					foreach (KeyValuePair<string, int> itemRequirement in entry.Value.ItemRequirements)
					{
						GameObject prefab = PrefabManager.Instance.GetPrefab(itemRequirement.Key);
						if ((Object)(object)prefab != (Object)null)
						{
							prefab.TryGetComponent<ItemDrop>(ref val3);
							if ((Object)(object)val3 != (Object)null)
							{
								GameObject val4 = Object.Instantiate<GameObject>(new GameObject("ReqItem_" + itemRequirement.Key), val2);
								Image val5 = val4.AddComponent<Image>();
								val4.GetComponent<RectTransform>().sizeDelta = new Vector2(50f, 50f);
								LayoutElement val6 = val4.AddComponent<LayoutElement>();
								val6.minHeight = 50f;
								val6.minWidth = 50f;
								val5.sprite = val3.m_itemData.GetIcon();
								GameObject val7 = GUIManager.Instance.CreateText($"{itemRequirement.Value}", val2, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-10f, 360f), GUIManager.Instance.AveriaSerifBold, 14, Color.grey, true, Color.black, 40f, 40f, false);
								LayoutElement val8 = val7.AddComponent<LayoutElement>();
								val8.minHeight = 10f;
								val8.minWidth = 10f;
								val7.transform.localPosition = new Vector3((float)num2, 0f);
								val4.transform.localPosition = new Vector3((float)num2, 0f);
								num2 += 45;
							}
						}
					}
				}
				Toggle component2 = ((Component)val.transform.Find("ChoiceHeader/selecter")).GetComponent<Toggle>();
				component2.group = SacrificeChoiceGroup;
				((UnityEvent<bool>)(object)component2.onValueChanged).AddListener((UnityAction<bool>)delegate
				{
					SelectedChoice = entry.Key;
				});
				SacrificeToggleOptions.Add(component2);
				num -= 180;
			}
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			Toggle();
			return true;
		}

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

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

		public string GetHoverName()
		{
			return Localization.instance.Localize("$ve_tribute_shrine");
		}
	}
}
namespace ValhallEternal.common
{
	public static class DataObjects
	{
		public enum DisplayStyle
		{
			Numeric,
			Roman,
			Nordic
		}

		public enum PrestigeEffect
		{
			Wings,
			Footprints,
			Aura,
			LevelColor,
			Title
		}

		public enum Oaths
		{
			DamageTakenIncrease,
			DealLessBluntDamage,
			DealLessPierceDamage,
			DealLessSlashDamage,
			DealLessAllDamage,
			LowerSkillGainBow,
			LowerSkillGainSword,
			LowerSkillGainClub,
			LowerSkillGainPolearms,
			LowerSkillGainKnives,
			LowerSkillGainRun,
			LowerSkillGainSneak,
			LowerSkillGainBloodMagic,
			LowerSkillGainElementalMagic,
			LowerSkillGainCrossbow,
			LowerSkillGainSpears,
			LowerSkillGainAxes,
			ReducePlayerHealthPercent,
			ReducePlayerStaminaPercent,
			ReducePlayerEitrPercent,
			ReducePlayerCarryWeight,
			NoBows,
			NoCrossbows
		}

		public enum Boons
		{
			IncreasePickableYields,
			SeedsGrowEverywhere,
			QualityNourishment,
			FishingProsperity,
			GefjunFeasts,
			RandomXPBonus,
			KnowledgeIsPower,
			HuntressArrowReturn,
			SwiftShadow,
			PowerfulShield,
			ExtraLoot,
			IncreaseEitrRegen,
			IncreaseStaminaRegen,
			ReturnStaminaOnDamage,
			ReturnEitrOnDamage,
			ReduceDodgeCost,
			BladeboundKnowledge,
			StormboundRage,
			IncreaseBaseEitr,
			IncreaseBaseStamina,
			IncreaseHeatResistance,
			MovementSpeedOnKill,
			ReduceWet,
			IncreaseMeleeDamage,
			Everwatchful,
			BrutalDefiance,
			DamageAgainstUndead,
			StrongerTowerBlock,
			DedicationToTheBlade,
			WealthOfAges,
			BuiltDifferent,
			GoddessOfWar,
			SeidrOfPlenty,
			PerfectForm,
			BalanceOfTheJotunn,
			BalanceOfTheAesir,
			HastenTheInevitable,
			ReduceFirePoison,
			HungerForKnowledge,
			BasicProtection,
			ArrowCatcher
		}

		public interface IProbability
		{
			string Name { get; set; }

			float SelectionWeight { get; set; }
		}

		public class LevelTextGradiant
		{
			public string TopLeft { get; set; }

			public string BottomLeft { get; set; }

			public string TopRight { get; set; }

			public string BottomRight { get; set; }
		}

		public class PlayerLevelConfiguration
		{
			public LevelTextGradiant TextColors { get; set; }

			public DisplayStyle DisplayStyle { get; set; }

			public int Level { get; set; }

			public Dictionary<Oaths, float> DifficultyOaths { get; set; }

			public Dictionary<Boons, float> DifficultyBoons { get; set; }
		}

		public class CompositePlayerConfig
		{
			public int PlayerLevel { get; set; } = 0;


			public bool ReduceSkillGainsActive { get; set; } = false;


			public bool DealReductedDamageActive { get; set; } = false;


			public Dictionary<Oaths, float> TotalOaths { get; set; } = new Dictionary<Oaths, float>();


			public Dictionary<Boons, float> TotalBoons { get; set; } = new Dictionary<Boons, float>();


			public Dictionary<PrestigeEffect, string> ActiveEffectsForPlayer { get; set; } = new Dictionary<PrestigeEffect, string>();


			public Dictionary<PrestigeEffect, List<string>> AvailableEffectsForPlayer { get; set; } = new Dictionary<PrestigeEffect, List<string>>
			{
				{
					PrestigeEffect.Wings,
					new List<string> { None }
				},
				{
					PrestigeEffect.Aura,
					new List<string> { None }
				}
			};


			public bool HasOath(Oaths oath, out float OathValue)
			{
				OathValue = 0f;
				if (TotalOaths.ContainsKey(oath))
				{
					OathValue = TotalOaths[oath];
					return true;
				}
				return false;
			}

			public bool HasOath(Oaths oath)
			{
				if (TotalOaths.ContainsKey(oath))
				{
					return true;
				}
				return false;
			}

			public bool HasBoon(Boons boon, out float BoonValue)
			{
				BoonValue = 0f;
				if (TotalBoons.ContainsKey(boon))
				{
					BoonValue = TotalBoons[boon];
					return true;
				}
				return false;
			}

			public bool HasBoon(Boons boon)
			{
				if (TotalBoons.ContainsKey(boon))
				{
					return true;
				}
				return false;
			}
		}

		[Serializable]
		public class PlayerLevelData
		{
			[DataMember]
			public int PlayerLevel { get; set; }

			[DataMember]
			public Dictionary<Oaths, float> PlayerOaths { get; set; }

			[DataMember]
			public Dictionary<Boons, float> PlayerBoons { get; set; }

			[DataMember]
			public Dictionary<PrestigeEffect, string> ActiveEffectsForPlayer { get; set; }

			[DataMember]
			public Dictionary<PrestigeEffect, List<string>> AvailableEffectsForPlayer { get; set; }
		}

		public class PlayerResetData
		{
			public float ResetSkillPercentage { get; set; } = 0.5f;


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


			public bool TeleportToSpawn { get; set; } = false;


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

		}

		public class PrestigeEffectDetails
		{
			public int LevelRequirement { get; set; }

			public Dictionary<Oaths, float> PlayerOathRequirements { get; set; }

			public Dictionary<Boons, float> PlayerBoonRequirements { get; set; }

			public PrestigeEffect EffectType { get; set; }

			public string EffectValue { get; set; }

			public bool PlayerMeetsPrestigeRequirements()
			{
				bool result = false;
				bool flag = false;
				bool flag2 = false;
				if (PlayerBoonRequirements != null && PlayerBoonRequirements.Count > 0)
				{
					foreach (KeyValuePair<Boons, float> playerBoonRequirement in PlayerBoonRequirements)
					{
						if (PlayerData.HasBoonWithValue(playerBoonRequirement.Key, out var value) && value > playerBoonRequirement.Value)
						{
							flag = true;
						}
					}
				}
				else
				{
					flag = true;
				}
				if (PlayerOathRequirements != null && PlayerOathRequirements.Count > 0)
				{
					foreach (KeyValuePair<Oaths, float> playerOathRequirement in PlayerOathRequirements)
					{
						if (PlayerData.HasOathWithValue(playerOathRequirement.Key, out var value2) && value2 > playerOathRequirement.Value)
						{
							flag2 = true;
						}
					}
				}
				else
				{
					flag2 = true;
				}
				if (LevelRequirement <= PlayerData.localPlayerConfig.PlayerLevel && flag && flag2)
				{
					result = true;
				}
				return result;
			}
		}

		[Serializable]
		public class Sacrifice
		{
			public string Name { get; set; }

			public string Description { get; set; }

			public PlayerResetData ResetPlayer { get; set; }

			public Dictionary<string, int> ItemRequirements { get; set; }

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

			public Dictionary<Oaths, float> PlayerOathRequirements { get; set; }

			public Dictionary<Boons, float> PlayerBoonRequirements { get; set; }

			[DataMember]
			public Dictionary<Oaths, float> PlayerOathChanges { get; set; }

			[DataMember]
			public Dictionary<Boons, float> PlayerBoonsChanges { get; set; }

			public Dictionary<Boons, float> PlayerBoonLimit { get; set; }

			public List<PrestigeEffectDetails> PrestigeOptions { get; set; }

			public string GetPlayerRequirementsDescription(bool includeOathsInDescription = true, bool includeBoonsInDescription = true, bool includeKeysInDescription = false, bool includeItemReference = true)
			{
				StringBuilder stringBuilder = new StringBuilder();
				if ((PlayerOathRequirements != null && PlayerOathRequirements.Count > 0) || (PlayerBoonRequirements != null && PlayerBoonRequirements.Count > 0) || (PlayerKeyRequirements != null && PlayerKeyRequirements.Count > 0))
				{
					stringBuilder.AppendLine(Localization.instance.Localize("$ve_requires"));
				}
				if (includeOathsInDescription && PlayerOathRequirements != null && PlayerOathRequirements.Count > 0)
				{
					foreach (KeyValuePair<Oaths, float> playerOathRequirement in PlayerOathRequirements)
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("{0} <color={1}>-($ve_oath)-</color> $ve_level_required {2}", LocalizeOath(playerOathRequirement.Key), "#ff4040", playerOathRequirement.Value)));
					}
				}
				if (stringBuilder.Length > 0)
				{
					stringBuilder.AppendLine("");
				}
				if (includeBoonsInDescription && PlayerBoonRequirements != null && PlayerBoonRequirements.Count > 0)
				{
					foreach (KeyValuePair<Boons, float> playerBoonRequirement in PlayerBoonRequirements)
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("{0} <color={1}>-($ve_boon)-</color> $ve_level_required {2}", LocalizeBoon(playerBoonRequirement.Key), "#b9f2ff", playerBoonRequirement.Value)));
					}
					stringBuilder.AppendLine("");
				}
				if (includeKeysInDescription && PlayerKeyRequirements != null && PlayerKeyRequirements.Count > 0)
				{
					foreach (string playerKeyRequirement in PlayerKeyRequirements)
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$ve_playerkey " + playerKeyRequirement));
					}
					stringBuilder.AppendLine("");
				}
				if (includeItemReference && ItemRequirements != null && ItemRequirements.Count > 0)
				{
					stringBuilder.AppendLine(Localization.instance.Localize("$ve_item_req"));
				}
				return stringBuilder.ToString();
			}

			public string GetChangesGrantedDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				if (PrestigeOptions != null && PrestigeOptions.Count > 0)
				{
					foreach (PrestigeEffectDetails prestigeOption in PrestigeOptions)
					{
						if (!PlayerData.PlayerHasPrestigeEffect(prestigeOption.EffectType, prestigeOption.EffectValue) && prestigeOption.PlayerMeetsPrestigeRequirements())
						{
							switch (prestigeOption.EffectType)
							{
							case PrestigeEffect.Wings:
								stringBuilder.AppendLine(Localization.instance.Localize("$ve_prestige_wings_granted $ve_" + prestigeOption.EffectValue + "_local") ?? "");
								break;
							case PrestigeEffect.Footprints:
								stringBuilder.AppendLine(Localization.instance.Localize("$ve_prestige_footprints_granted $ve_" + prestigeOption.EffectValue + "_local") ?? "");
								break;
							case PrestigeEffect.Aura:
								stringBuilder.AppendLine(Localization.instance.Localize("$ve_prestige_aura_granted $ve_" + prestigeOption.EffectValue + "_local") ?? "");
								break;
							case PrestigeEffect.LevelColor:
								stringBuilder.AppendLine(Localization.instance.Localize("$ve_prestige_levelcolor_granted $ve_" + prestigeOption.EffectValue + "_local") ?? "");
								break;
							case PrestigeEffect.Title:
								stringBuilder.AppendLine(Localization.instance.Localize("$ve_prestige_title_granted $ve_" + prestigeOption.EffectValue + "_local") ?? "");
								break;
							}
						}
					}
				}
				if (PlayerOathChanges != null && PlayerOathChanges.Count > 0)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.AppendLine("");
					}
					stringBuilder.AppendLine(Localization.instance.Localize("$ve_oath_changes") ?? "");
					foreach (KeyValuePair<Oaths, float> playerOathChange in PlayerOathChanges)
					{
						if (playerOathChange.Value > 0f)
						{
							stringBuilder.AppendLine(Localization.instance.Localize(string.Format("  « <size=18>{0}</size> <color={1}>+{2}</color> | {3}\n", LocalizeOath(playerOathChange.Key), "#b9f2ff", playerOathChange.Value, LocalizeOathDesc(playerOathChange.Key, playerOathChange.Value))));
						}
						else
						{
							stringBuilder.AppendLine(Localization.instance.Localize(string.Format("  « <size=18>{0}</size> <color={1}>-{2}</color> | {3}\n", LocalizeOath(playerOathChange.Key), "#ff4040", playerOathChange.Value, LocalizeOathDesc(playerOathChange.Key, playerOathChange.Value))));
						}
					}
				}
				if (PlayerBoonsChanges != null && PlayerBoonsChanges.Count > 0)
				{
					if (PlayerOathChanges != null && PlayerOathChanges.Count > 0)
					{
						stringBuilder.AppendLine("");
					}
					stringBuilder.AppendLine(Localization.instance.Localize("$ve_boon_changes") ?? "");
					foreach (KeyValuePair<Boons, float> playerBoonsChange in PlayerBoonsChanges)
					{
						if (playerBoonsChange.Value > 0f)
						{
							stringBuilder.AppendLine(Localization.instance.Localize(string.Format("  » <size=18>{0}</size> <color={1}>+{2}</color> | {3}\n", LocalizeBoon(playerBoonsChange.Key), "#b9f2ff", playerBoonsChange.Value, LocalizeBoonDesc(playerBoonsChange.Key))));
						}
						else
						{
							stringBuilder.AppendLine(Localization.instance.Localize(string.Format("  » <size=18>{0}</size> <color={1}>-{2}</color> | {3}\n", LocalizeBoon(playerBoonsChange.Key), "#ff4040", playerBoonsChange.Value, LocalizeBoonDesc(playerBoonsChange.Key))));
						}
					}
				}
				return stringBuilder.ToString();
			}

			public string GetResetDetails()
			{
				StringBuilder stringBuilder = new StringBuilder();
				if (ResetPlayer != null)
				{
					stringBuilder.AppendLine(Localization.instance.Localize("$ve_this_prestige"));
					if (ResetPlayer.ResetSkillPercentage > 0f)
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$ve_skill_decrease <color={0}>{1}%</color>", "#ff4040", ResetPlayer.ResetSkillPercentage * 100f)));
					}
					if (ResetPlayer.ResetKnownRecipes)
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$ve_forget_all_recipes"));
					}
					if (ResetPlayer.TeleportToSpawn)
					{
						stringBuilder.AppendLine(Localization.instance.Localize("$ve_teleport_to_spawn"));
					}
					if (ResetPlayer.PrestigeLevelsGained > 0)
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$ve_you_gain <color={0}>{1}</color> $ve_prestige_levels", "#b9f2ff", ResetPlayer.PrestigeLevelsGained)));
					}
					if (ResetPlayer.PrestigeLevelsGained < 0)
					{
						stringBuilder.AppendLine(Localization.instance.Localize(string.Format("$ve_you_loose <color={0}>{1}</color> $ve_prestige_levels", "#ff4040", ResetPlayer.PrestigeLevelsGained)));
					}
				}
				return stringBuilder.ToString();
			}

			public string GetTotalDescription(bool showreqboons = true, bool showreqoaths = true)
			{
				string playerRequirementsDescription = GetPlayerRequirementsDescription(showreqoaths, showreqboons);
				string resetDetails = GetResetDetails();
				string text = "";
				text += GetChangesGrantedDescription();
				if (resetDetails.Length > 0)
				{
					text += "\n";
				}
				text += resetDetails;
				if (playerRequirementsDescription.Length > 0)
				{
					text += "\n";
				}
				return text + playerRequirementsDescription;
			}
		}

		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 PrestigeEffectsDictionaryZNetProperty : ZNetProperty<Dictionary<PrestigeEffect, string>>
		{
			public PrestigeEffectsDictionaryZNetProperty(string key, ZNetView zNetView, Dictionary<PrestigeEffect, string> defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}

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

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

		public static readonly string CustomLevelZKey = "VELevel";

		public static readonly string CustomDataKey = "VE_DATA";

		public static readonly string CustomPrestigeFxZKey = "VE_PrestigeFx";

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

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

		public static ISerializer yamlserializerJsonCompat = ((BuilderSkeleton<SerializerBuilder>)new SerializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).JsonCompatible().Build();

		public static BinaryFormatter binFormatter = new BinaryFormatter();

		public static Sprite boonbackground;

		public static Sprite hastenDeath;

		public static GameObject BoonGrantedVFX;

		private const string color_increase = "#b9f2ff";

		private const string color_decrease = "#ff4040";

		public static readonly string HarvestingBonusColor = "#ffc87c";

		public static readonly string FishBountyBonusColor = "#619CFF";

		public static readonly string None = "None";

		public static readonly List<Oaths> DamageReductionOaths = new List<Oaths>
		{
			Oaths.DealLessBluntDamage,
			Oaths.DealLessPierceDamage,
			Oaths.DealLessSlashDamage
		};

		public static readonly List<Oaths> ReducedSkillGainOaths = new List<Oaths>
		{
			Oaths.LowerSkillGainBow,
			Oaths.LowerSkillGainSword,
			Oaths.LowerSkillGainClub,
			Oaths.LowerSkillGainPolearms,
			Oaths.LowerSkillGainKnives,
			Oaths.LowerSkillGainRun,
			Oaths.LowerSkillGainSneak,
			Oaths.LowerSkillGainElementalMagic,
			Oaths.LowerSkillGainBloodMagic,
			Oaths.LowerSkillGainCrossbow,
			Oaths.LowerSkillGainSpears,
			Oaths.LowerSkillGainAxes
		};

		public static void LoadAssets()
		{
			boonbackground = ValhallEternal.EmbeddedResourceBundle.LoadAsset<Sprite>("assets/art/bottom_border_divider.png");
			hastenDeath = ValhallEternal.EmbeddedResourceBundle.LoadAsset<Sprite>("assets/art/hastenDeath.png");
			BoonGrantedVFX = ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/boons/boongranted.prefab");
			HastenTheInevitable.AddHastenDeathStatus();
		}

		public static string LocalizeOath(Oaths oath)
		{
			return $"$ve_{oath}";
		}

		public static string LocalizeOathDesc(Oaths oath, float value = 0f)
		{
			if (value > 0f)
			{
				return string.Format(Localization.instance.Localize($"$ve_{oath}_desc"), value);
			}
			return $"$ve_{oath}_desc_noval";
		}

		public static string LocalizeBoon(Boons boon)
		{
			return $"$ve_{boon}";
		}

		public static string LocalizeBoonDesc(Boons boon, float value = 0f)
		{
			if (value > 0f)
			{
				return string.Format(Localization.instance.Localize($"$ve_{boon}_desc"), value);
			}
			return $"$ve_{boon}_desc_noval";
		}
	}
	public static class Deities
	{
		public enum Deity
		{
			Baldur,
			Hel,
			Gefjun,
			Skaldi,
			Freya,
			Vor,
			Syn
		}

		public class PrestigeEffectDetails
		{
			public GameObject EffectObject { get; set; }

			public DataObjects.LevelTextGradiant LevelText { get; set; }

			public string Title { get; set; }
		}

		public class DeityDetails
		{
			public Sprite Image { get; set; }

			public string NameLocalKey { get; set; }

			public string DescriptionLocalKey { get; set; }
		}

		internal static Dictionary<Deity, DeityDetails> DeityConfiguration = new Dictionary<Deity, DeityDetails>();

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

		internal static Dictionary<DataObjects.PrestigeEffect, Dictionary<string, PrestigeEffectDetails>> PrestigeEffects = new Dictionary<DataObjects.PrestigeEffect, Dictionary<string, PrestigeEffectDetails>>
		{
			{
				DataObjects.PrestigeEffect.Wings,
				new Dictionary<string, PrestigeEffectDetails>()
			},
			{
				DataObjects.PrestigeEffect.Aura,
				new Dictionary<string, PrestigeEffectDetails>()
			},
			{
				DataObjects.PrestigeEffect.Footprints,
				new Dictionary<string, PrestigeEffectDetails>()
			}
		};

		internal static void LoadDietyConfigurations()
		{
			AddDeityConfiguration(Deity.Baldur, ValhallEternal.EmbeddedResourceBundle.LoadAsset<Sprite>("assets/art/baladur_nobackground.png"));
			AddDeityConfiguration(Deity.Hel, ValhallEternal.EmbeddedResourceBundle.LoadAsset<Sprite>("assets/art/hel_nobackground.png"));
			AddDeityConfiguration(Deity.Gefjun, ValhallEternal.EmbeddedResourceBundle.LoadAsset<Sprite>("assets/art/gefjun_nobackground.png"));
			AddDeityConfiguration(Deity.Skaldi, ValhallEternal.EmbeddedResourceBundle.LoadAsset<Sprite>("assets/art/skaldi_nobackground.png"));
			AddDeityConfiguration(Deity.Freya, ValhallEternal.EmbeddedResourceBundle.LoadAsset<Sprite>("assets/art/freya_nobackground.png"));
			AddDeityConfiguration(Deity.Vor, ValhallEternal.EmbeddedResourceBundle.LoadAsset<Sprite>("assets/art/vor_nobackground.png"));
			AddDeityConfiguration(Deity.Syn, ValhallEternal.EmbeddedResourceBundle.LoadAsset<Sprite>("assets/art/syn_nobackground.png"));
			AddEffect("leafburstverticle", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/boons/harvestbonus.prefab"));
			AddEffect("vinepulseinward", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/boons/naturegeneric.prefab"));
			AddEffect("snowswirl", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/boons/snowswirlsoft.prefab"));
			AddEffect("goldenswirl", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/boons/goldenswirl.prefab"));
			AddPrestigeEffect(DataObjects.PrestigeEffect.Wings, "natureWings", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/leveldisplay/wings/naturewings.prefab"));
			AddPrestigeEffect(DataObjects.PrestigeEffect.Aura, "natureAura", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/leveldisplay/aura/natureaura.prefab"));
			AddPrestigeEffect(DataObjects.PrestigeEffect.Aura, "lightAura", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/leveldisplay/aura/lightaura.prefab"));
			AddPrestigeEffect(DataObjects.PrestigeEffect.Aura, "fireAura", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/leveldisplay/aura/fireaura.prefab"));
			AddPrestigeEffect(DataObjects.PrestigeEffect.Aura, "frostAura", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/leveldisplay/aura/frostaura.prefab"));
			AddPrestigeEffect(DataObjects.PrestigeEffect.Aura, "darkAura", ValhallEternal.EmbeddedResourceBundle.LoadAsset<GameObject>("assets/leveldisplay/aura/darkaura.prefab"));
		}

		internal static void AddPrestigeEffect(DataObjects.PrestigeEffect type, string key, GameObject asset)
		{
			if (type != DataObjects.PrestigeEffect.Aura && type != 0 && type != DataObjects.PrestigeEffect.Footprints)
			{
				Logger.LogWarning("Refused to add (" + key + ") incorrect Prestige effect as a game asset.");
			}
			else if (!PrestigeEffects[type].ContainsKey(key))
			{
				PrestigeEffects[type].Add(key, new PrestigeEffectDetails
				{
					EffectObject = asset
				});
				PrefabManager.Instance.AddPrefab(asset);
			}
		}

		internal static void AddPrestigeLevelText(string key, string topRight, string topLeft, string bottomRight, string bottomLeft)
		{
			if (!PrestigeEffects[DataObjects.PrestigeEffect.LevelColor].ContainsKey(key))
			{
				PrestigeEffects[DataObjects.PrestigeEffect.LevelColor].Add(key, new PrestigeEffectDetails
				{
					LevelText = new DataObjects.LevelTextGradiant
					{
						BottomLeft = bottomLeft,
						BottomRight = bottomRight,
						TopLeft = topLeft,
						TopRight = topRight
					}
				});
			}
		}

		internal static void AddDeityConfiguration(Deity deity, Sprite image)
		{
			DeityDetails value = new DeityDetails
			{
				Image = image,
				NameLocalKey = "$ve_" + deity.ToString().ToLower() + "_header",
				DescriptionLocalKey = "$ve_" + deity.ToString().ToLower() + "_description"
			};
			DeityConfiguration.Add(deity, value);
		}

		internal static void AddEffect(string key, GameObject asset)
		{
			if (!DeityEffects.ContainsKey(key))
			{
				DeityEffects.Add(key, asset);
				PrefabManager.Instance.AddPrefab(asset);
			}
		}

		public static List<OptionData> DeityOptions()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			List<OptionData> list = new List<OptionData>();
			foreach (Deity item in DeityConfiguration.Keys.ToList())
			{
				list.Add(new OptionData
				{
					text = item.ToString()
				});
			}
			return list;
		}
	}
	internal static class Extensions
	{
		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)
		{
			List<string> uniqueKeys = player.GetUniqueKeys();
			foreach (string item in uniqueKeys)
			{
				if (item.StartsWith(key))
				{
					((Humanoid)player).RemoveUniqueKey(item);
					return true;
				}
			}
			return false;
		}

		public static Dictionary<string, int> GetItemTotalsByName(this Inventory inv)
		{
			List<ItemData> allItems = inv.GetAllItems();
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (ItemData item in allItems)
			{
				if (dictionary.ContainsKey(((Object)item.m_dropPrefab).name))
				{
					dictionary[((Object)item.m_dropPrefab).name] += item.m_stack;
				}
				else
				{
					dictionary.Add(((Object)item.m_dropPrefab).name, item.m_stack);
				}
			}
			return dictionary;
		}

		public static bool RemoveItemByPrefab(this Inventory inv, string prefab, int countToRemove)
		{
			List<ItemData> allItems = inv.GetAllItems();
			int num = countToRemove;
			List<ItemData> list = new List<ItemData>();
			foreach (ItemData item in allItems)
			{
				if (!(((Object)item.m_dropPrefab).name == prefab))
				{
					continue;
				}
				if (item.m_stack > 0)
				{
					if (num < item.m_stack)
					{
						item.m_stack -= num;
						num = 0;
						break;
					}
					if (item.m_stack <= num)
					{
						list.Add(item);
						num -= item.m_stack;
					}
					else
					{
						item.m_stack -= num;
						num = 0;
					}
				}
				else
				{
					list.Add(item);
				}
			}
			foreach (ItemData item2 in list)
			{
				inv.RemoveItem(item2);
			}
			Logger.LogDebug($"Remove summary: {prefab}x{countToRemove} successfully removed: {countToRemove - num}");
			return num == 0;
		}

		public static float GetTotalDamageNoHarvestValues(this DamageTypes dmgs, float poisonMod = 0.5f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			float num = dmgs.m_frost + dmgs.m_fire + dmgs.m_spirit + dmgs.m_lightning + dmgs.m_blunt + dmgs.m_slash + dmgs.m_pierce;
			return num + dmgs.m_poison * poisonMod;
		}

		public static string RandomSelectFromWeightedListWithExclusions(List<DataObjects.IProbability> listOfWeights, List<string> exclude = null)
		{
			if (exclude == null)
			{
				exclude = new List<string>();
			}
			List<DataObjects.IProbability> list = listOfWeights.Where((DataObjects.IProbability x) => !exclude.Contains(x.Name)).ToList();
			float num = list.Select((DataObjects.IProbability x) => x.SelectionWeight).Sum();
			if (num == 0f)
			{
				return null;
			}
			float num2 = Random.Range(0f, num);
			float num3 = 0f;
			foreach (DataObjects.IProbability listOfWeight in listOfWeights)
			{
				num3 += listOfWeight.SelectionWeight;
				if (num3 >= num2)
				{
					return listOfWeight.Name;
				}
			}
			return list.ToArray()[Random.Range(0, listOfWeights.Count - 1)].Name;
		}

		internal static void DropItemsImmediate(Dictionary<GameObject, int> drops, Vector3 centerPos, float dropArea)
		{
			//IL_0056: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<GameObject, int> drop in drops)
			{
				bool flag = false;
				int num = 0;
				GameObject key = drop.Key;
				int value = drop.Value;
				Logger.LogDebug($"Dropping {((Object)key).name} {value}");
				for (int i = 0; i < value; i++)
				{
					GameObject val = Object.Instantiate<GameObject>(key, centerPos, Quaternion.identity);
					ItemDrop component = val.GetComponent<ItemDrop>();
					if (!flag)
					{
						flag = true;
						if (Object.op_Implicit((Object)(object)component))
						{
							num = component.m_itemData.m_shared.m_maxStackSize;
						}
					}
					if (component != null)
					{
						int num2 = value - i;
						if (num2 > 0)
						{
							if (value > num)
							{
								component.m_itemData.m_stack = num;
								i += num;
							}
							else
							{
								component.m_itemData.m_stack = num2;
								i += num2;
							}
						}
						component.m_itemData.m_worldLevel = (byte)Game.m_worldLevel;
					}
					Rigidbody component2 = val.GetComponent<Rigidbody>();
					if (Object.op_Implicit((Object)(object)component2))
					{
						Vector3 val2 = Random.insideUnitSphere * dropArea;
						if (val2.y < 0f)
						{
							val2.y = 0f - val2.y;
						}
						component2.AddForce(val2 * 5f, (ForceMode)2);
					}
				}
			}
		}
	}
	public static class PrestigeLevelConfigData
	{
		public static Dictionary<int, DataObjects.PlayerLevelConfiguration> activePlayerConfig = defaultPlayerConfig;

		internal static Dictionary<int, DataObjects.PlayerLevelConfiguration> defaultPlayerConfig = new Dictionary<int, DataObjects.PlayerLevelConfiguration>
		{
			{
				1,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						5f
					} }
				}
			},
			{
				2,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						10f
					} }
				}
			},
			{
				3,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						15f
					} }
				}
			},
			{
				4,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						20f
					} }
				}
			},
			{
				5,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						25f
					} }
				}
			},
			{
				6,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						30f
					} }
				}
			},
			{
				7,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						35f
					} }
				}
			},
			{
				8,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						40f
					} }
				}
			},
			{
				9,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						45f
					} }
				}
			},
			{
				10,
				new DataObjects.PlayerLevelConfiguration
				{
					TextColors = new DataObjects.LevelTextGradiant
					{
						TopLeft = "#FFB431FF",
						BottomLeft = "#FF6900FF",
						TopRight = "#E7A500FF",
						BottomRight = "#EE5B00FF"
					},
					DisplayStyle = DataObjects.DisplayStyle.Numeric,
					Level = 1,
					DifficultyOaths = new Dictionary<DataObjects.Oaths, float> { 
					{
						DataObjects.Oaths.DamageTakenIncrease,
						50f
					} }
				}
			}
		};

		public static DataObjects.PlayerLevelConfiguration GetPlayerLevelConfiguration(int prestigeLevel)
		{
			if (activePlayerConfig != null && activePlayerConfig.ContainsKey(prestigeLevel))
			{
				return activePlayerConfig[prestigeLevel];
			}
			return new DataObjects.PlayerLevelConfiguration();
		}
	}
	internal static class ProgressionCompat
	{
		private static bool progressionResolved;

		private static MethodInfo ProgressionRemovePrivateKey;

		private static object PRPInstance;

		private static void Resolve()
		{
			if (progressionResolved)
			{
				return;
			}
			progressionResolved = true;
			Type type = AccessTools.TypeByName("VentureValheim.Progression.KeyManager");
			if (!(type == null))
			{
				PRPInstance = AccessTools.Property(type, "Instance")?.GetValue(null);
				if (PRPInstance != null)
				{
					ProgressionRemovePrivateKey = AccessTools.Method(type, "RemovePrivateKey", new Type[1] { typeof(string) }, (Type[])null);
				}
			}
		}

		public static bool TryRemovePrivateKey(string key)
		{
			Resolve();
			if (ProgressionRemovePrivateKey == null || PRPInstance == null)
			{
				return false;
			}
			try
			{
				ProgressionRemovePrivateKey.Invoke(PRPInstance, new object[1] { key });
				return true;
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to remove VentureValheim private key '" + key + "': " + ex.Message);
				return false;
			}
		}
	}
	public static class SacrificeData
	{
		public static Dictionary<Deities.Deity, Dictionary<string, DataObjects.Sacrifice>> AllSacrifices = new Dictionary<Deities.Deity, Dictionary<string, DataObjects.Sacrifice>>();

		internal static Dictionary<Deities.Deity, Dictionary<string, DataObjects.Sacrifice>> DefaultSacrifices = new Dictionary<Deities.Deity, Dictionary<string, DataObjects.Sacrifice>>
		{
			{
				Deities.Deity.Gefjun,
				new Dictionary<string, DataObjects.Sacrifice>
				{
					{
						"T1",
						new DataObjects.Sacrifice
						{
							Name = "Bounty of the lands",
							Description = "A tribute for the goddess of harvests, may your harvests be plenty.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyBoar", 10 } },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreasePickableYields,
								2f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreasePickableYields,
								100f
							} }
						}
					},
					{
						"T2",
						new DataObjects.Sacrifice
						{
							Name = "Quality Nourishment",
							Description = "Gefjun enhances your food, making every bite more nurishing.",
							ItemRequirements = new Dictionary<string, int>
							{
								{ "TrophyBoar", 8 },
								{ "TrophyDeer", 5 },
								{ "TrophyNeck", 2 }
							},
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreasePickableYields,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.QualityNourishment,
								2f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.QualityNourishment,
								100f
							} }
						}
					},
					{
						"T3",
						new DataObjects.Sacrifice
						{
							Name = "Fishing Prosperity",
							Description = "May no fish escape your grasp.",
							ItemRequirements = new Dictionary<string, int> { { "Fish1", 10 } },
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreasePickableYields,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.FishingProsperity,
								2f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.FishingProsperity,
								100f
							} }
						}
					},
					{
						"T4",
						new DataObjects.Sacrifice
						{
							Name = "Devotion for Gefjun",
							Description = "Provides a small amount of permenant armor. This is a prestige level.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyEikthyr", 1 } },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.BasicProtection,
								1f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.BasicProtection,
								20f
							} },
							PlayerOathChanges = new Dictionary<DataObjects.Oaths, float> { 
							{
								DataObjects.Oaths.DamageTakenIncrease,
								5f
							} },
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.FishingProsperity,
								1f
							} },
							PlayerKeyRequirements = new List<string> { "defeated_eikthyr", "defeated_gdking", "defeated_bonemass", "defeated_dragon", "defeated_goblinking", "defeated_queen", "defeated_fader" },
							ResetPlayer = new DataObjects.PlayerResetData
							{
								ResetSkillPercentage = 0.5f,
								TeleportToSpawn = true,
								PrestigeLevelsGained = 1
							},
							PrestigeOptions = new List<DataObjects.PrestigeEffectDetails>
							{
								new DataObjects.PrestigeEffectDetails
								{
									EffectType = DataObjects.PrestigeEffect.Aura,
									EffectValue = "natureAura",
									LevelRequirement = 5
								}
							}
						}
					}
				}
			},
			{
				Deities.Deity.Vor,
				new Dictionary<string, DataObjects.Sacrifice>
				{
					{
						"T1",
						new DataObjects.Sacrifice
						{
							Name = "Wisdom of the Ages",
							Description = "A tribute to Vör. Grants you a chance to recieve bonus skill experiance.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyGreydwarf", 10 } },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.RandomXPBonus,
								1f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.RandomXPBonus,
								100f
							} }
						}
					},
					{
						"T2",
						new DataObjects.Sacrifice
						{
							Name = "Bladebound Knowledge",
							Description = "Combat skills sometimes provide gains to non-combat skills.",
							ItemRequirements = new Dictionary<string, int>
							{
								{ "TrophyGreydwarfBrute", 2 },
								{ "TrophyGreydwarfShaman", 2 },
								{ "TrophyGhost", 2 }
							},
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.RandomXPBonus,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.BladeboundKnowledge,
								2f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.BladeboundKnowledge,
								100f
							} }
						}
					},
					{
						"T3",
						new DataObjects.Sacrifice
						{
							Name = "Hunger For Knowledge",
							Description = "Discovering a recipe provides a small amount of experiance to a random skill.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyFrostTroll", 10 } },
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.BladeboundKnowledge,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.HungerForKnowledge,
								5f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.HungerForKnowledge,
								100f
							} }
						}
					}
				}
			},
			{
				Deities.Deity.Baldur,
				new Dictionary<string, DataObjects.Sacrifice>
				{
					{
						"T1",
						new DataObjects.Sacrifice
						{
							Name = "Shield Wall",
							Description = "A tribute to Baldur. Shields become more powerful in your hands.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyAbomination", 2 } },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.PowerfulShield,
								3f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.PowerfulShield,
								100f
							} }
						}
					},
					{
						"T2",
						new DataObjects.Sacrifice
						{
							Name = "Light of Baldur",
							Description = "You deal increased damage against undead.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyDraugr", 6 } },
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.PowerfulShield,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.DamageAgainstUndead,
								2f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.DamageAgainstUndead,
								100f
							} }
						}
					},
					{
						"T3",
						new DataObjects.Sacrifice
						{
							Name = "Purify",
							Description = "Significantly reduces poison duration, reduces fire damage taken. TODO",
							ItemRequirements = new Dictionary<string, int>
							{
								{ "TrophyEikthyr", 1 },
								{ "TrophyTheElder", 1 },
								{ "TrophyBonemass", 1 }
							},
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.DamageAgainstUndead,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.ReduceFirePoison,
								3f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.ReduceFirePoison,
								80f
							} },
							PlayerOathChanges = new Dictionary<DataObjects.Oaths, float> { 
							{
								DataObjects.Oaths.DamageTakenIncrease,
								5f
							} },
							ResetPlayer = new DataObjects.PlayerResetData
							{
								ResetSkillPercentage = 0.5f,
								TeleportToSpawn = true,
								PrestigeLevelsGained = 1
							},
							PlayerKeyRequirements = new List<string> { "defeated_eikthyr", "defeated_gdking", "defeated_bonemass", "defeated_dragon", "defeated_goblinking", "defeated_queen", "defeated_fader" },
							PrestigeOptions = new List<DataObjects.PrestigeEffectDetails>
							{
								new DataObjects.PrestigeEffectDetails
								{
									EffectType = DataObjects.PrestigeEffect.Aura,
									EffectValue = "lightAura",
									LevelRequirement = 10
								}
							}
						}
					}
				}
			},
			{
				Deities.Deity.Skaldi,
				new Dictionary<string, DataObjects.Sacrifice>
				{
					{
						"T1",
						new DataObjects.Sacrifice
						{
							Name = "Swift is the Shadow",
							Description = "A tribute to Skaði. Under the cover of darkness or in mountains she hastens your sprint.",
							ItemRequirements = new Dictionary<string, int>
							{
								{ "TrophyWolf", 10 },
								{ "TrophyUlv", 5 }
							},
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.SwiftShadow,
								1f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.SwiftShadow,
								100f
							} }
						}
					},
					{
						"T2",
						new DataObjects.Sacrifice
						{
							Name = "Stormbound Rage",
							Description = "Skaði teaches you to channel the rage of the storm, you deal bonus lightning damage during storms.",
							ItemRequirements = new Dictionary<string, int>
							{
								{ "TrophyCultist_Hildir", 1 },
								{ "TrophyFenring", 2 }
							},
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.SwiftShadow,
								2f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.StormboundRage,
								2f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.StormboundRage,
								100f
							} }
						}
					},
					{
						"T3",
						new DataObjects.Sacrifice
						{
							Name = "Huntress Prowess",
							Description = "Skaði gives you a chance to gain arrows from creature kills.",
							ItemRequirements = new Dictionary<string, int>
							{
								{ "TrophyEikthyr", 1 },
								{ "TrophyTheElder", 1 },
								{ "TrophyBonemass", 1 },
								{ "TrophyDragonQueen", 1 }
							},
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.SwiftShadow,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.HuntressArrowReturn,
								2f
							} },
							PlayerOathChanges = new Dictionary<DataObjects.Oaths, float> { 
							{
								DataObjects.Oaths.DamageTakenIncrease,
								5f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.HuntressArrowReturn,
								100f
							} },
							ResetPlayer = new DataObjects.PlayerResetData
							{
								ResetSkillPercentage = 0.5f,
								TeleportToSpawn = true,
								PrestigeLevelsGained = 1
							},
							PlayerKeyRequirements = new List<string> { "defeated_eikthyr", "defeated_gdking", "defeated_bonemass", "defeated_dragon", "defeated_goblinking", "defeated_queen", "defeated_fader" },
							PrestigeOptions = new List<DataObjects.PrestigeEffectDetails>
							{
								new DataObjects.PrestigeEffectDetails
								{
									EffectType = DataObjects.PrestigeEffect.Aura,
									EffectValue = "frostAura",
									LevelRequirement = 10
								}
							}
						}
					}
				}
			},
			{
				Deities.Deity.Syn,
				new Dictionary<string, DataObjects.Sacrifice>
				{
					{
						"T1",
						new DataObjects.Sacrifice
						{
							Name = "Built Different",
							Description = "A tribute to Syn. Increases how much stagger damage you can take before becoming staggered.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyGrowth", 2 } },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.BuiltDifferent,
								2f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.BuiltDifferent,
								100f
							} }
						}
					},
					{
						"T2",
						new DataObjects.Sacrifice
						{
							Name = "Wealth of the Ages",
							Description = "Greater Tribute to Syn. Gives a chance to loot valuable items when killing creatures.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyDeathsquito", 3 } },
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.BuiltDifferent,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.WealthOfAges,
								1f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.WealthOfAges,
								100f
							} }
						}
					},
					{
						"T3",
						new DataObjects.Sacrifice
						{
							Name = "Dedication to the Blade",
							Description = "Increases melee damage done, reduces your ranged damage done.",
							ItemRequirements = new Dictionary<string, int>
							{
								{ "TrophyGoblinBruteBrosShaman", 1 },
								{ "TrophyGoblinBruteBrosBrute", 1 }
							},
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.WealthOfAges,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float>
							{
								{
									DataObjects.Boons.DedicationToTheBlade,
									2.5f
								},
								{
									DataObjects.Boons.IncreaseMeleeDamage,
									5f
								}
							},
							PlayerOathChanges = new Dictionary<DataObjects.Oaths, float> { 
							{
								DataObjects.Oaths.DamageTakenIncrease,
								5f
							} },
							PlayerKeyRequirements = new List<string> { "defeated_eikthyr", "defeated_gdking", "defeated_bonemass", "defeated_dragon", "defeated_goblinking", "defeated_queen", "defeated_fader" },
							ResetPlayer = new DataObjects.PlayerResetData
							{
								ResetSkillPercentage = 0.5f,
								TeleportToSpawn = true,
								PrestigeLevelsGained = 1
							},
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float>
							{
								{
									DataObjects.Boons.DedicationToTheBlade,
									100f
								},
								{
									DataObjects.Boons.IncreaseMeleeDamage,
									200f
								}
							}
						}
					}
				}
			},
			{
				Deities.Deity.Freya,
				new Dictionary<string, DataObjects.Sacrifice>
				{
					{
						"T1",
						new DataObjects.Sacrifice
						{
							Name = "Seiðr of Plenty",
							Description = "Freya invokes magic to increase your Eitr reserves and your Eitr regeneration.",
							ItemRequirements = new Dictionary<string, int> { { "TrophySeeker", 5 } },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float>
							{
								{
									DataObjects.Boons.IncreaseEitrRegen,
									1f
								},
								{
									DataObjects.Boons.IncreaseBaseEitr,
									3f
								}
							},
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float>
							{
								{
									DataObjects.Boons.IncreaseEitrRegen,
									100f
								},
								{
									DataObjects.Boons.IncreaseBaseEitr,
									200f
								}
							}
						}
					},
					{
						"T1.1",
						new DataObjects.Sacrifice
						{
							Name = "Goddess of War",
							Description = "Freya imbues some knowledge of battle to you, increasing your stamina regeneration.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyGjall", 3 } },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreaseStaminaRegen,
								3f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreaseStaminaRegen,
								100f
							} }
						}
					},
					{
						"T2",
						new DataObjects.Sacrifice
						{
							Name = "Perfect Form",
							Description = "Freya teach you precision in the art of war. This gives you an innate chance to deal critical damage.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyCultist_Hildir", 1 } },
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreaseStaminaRegen,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.PerfectForm,
								2f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.PerfectForm,
								100f
							} }
						}
					}
				}
			},
			{
				Deities.Deity.Hel,
				new Dictionary<string, DataObjects.Sacrifice>
				{
					{
						"T1",
						new DataObjects.Sacrifice
						{
							Name = "Hellfire Adaptation",
							Description = "A tribute to Hel. Your resistance to extreme heat increases.",
							ItemRequirements = new Dictionary<string, int>
							{
								{ "TrophyCharredMelee", 2 },
								{ "TrophyCharredArcher", 2 },
								{ "TrophyVolture", 2 }
							},
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreaseHeatResistance,
								3f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreaseHeatResistance,
								100f
							} }
						}
					},
					{
						"T2",
						new DataObjects.Sacrifice
						{
							Name = "Balance of the Jotunn",
							Description = "Taking damage returns some eitr.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyMorgen", 1 } },
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreaseHeatResistance,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.ReturnStaminaOnDamage,
								3f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.ReturnStaminaOnDamage,
								100f
							} }
						}
					},
					{
						"T2.1",
						new DataObjects.Sacrifice
						{
							Name = "Balance of the Aesir",
							Description = "Taking damage returns some stamina.",
							ItemRequirements = new Dictionary<string, int> { { "TrophyFallenValkyrie", 1 } },
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.IncreaseHeatResistance,
								1f
							} },
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.ReturnEitrOnDamage,
								3f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.ReturnEitrOnDamage,
								100f
							} }
						}
					},
					{
						"T3",
						new DataObjects.Sacrifice
						{
							Name = "Hasten the inevitable",
							Description = "Hel hastens your movement after a kill",
							ItemRequirements = new Dictionary<string, int> { { "TrophyFallenValkyrie", 1 } },
							PlayerBoonRequirements = new Dictionary<DataObjects.Boons, float>
							{
								{
									DataObjects.Boons.ReturnStaminaOnDamage,
									1f
								},
								{
									DataObjects.Boons.ReturnEitrOnDamage,
									1f
								}
							},
							PlayerBoonsChanges = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.MovementSpeedOnKill,
								2f
							} },
							PlayerBoonLimit = new Dictionary<DataObjects.Boons, float> { 
							{
								DataObjects.Boons.MovementSpeedOnKill,
								200f
							} },
							PlayerOathChanges = new Dictionary<DataObjects.Oaths, float> { 
							{
								DataObjects.Oaths.DamageTakenIncrease,
								5f
							} },
							PlayerKeyRequirements = new List<string> { "defeated_eikthyr", "defeated_gdking", "defeated_bonemass", "defeated_dragon", "defeated_goblinking", "defeated_queen", "defeated_fader" },
							ResetPlayer = new DataObjects.PlayerResetData
							{
								ResetSkillPercentage = 0.5f,
								TeleportToSpawn = true,
								PrestigeLevelsGained = 1
							},
							PrestigeOptions = new List<DataObjects.PrestigeEffectDetails>
							{
								new DataObjects.PrestigeEffectDetails
								{
									EffectType = DataObjects.PrestigeEffect.Aura,
									EffectValue = "fireAura",
									LevelRequirement = 15
								},
								new DataObjects.PrestigeEffectDetails
								{
									EffectType = DataObjects.PrestigeEffect.Aura,
									EffectValue = "darkAura",
									LevelRequirement = 20
								}
							}
						}
					}
				}
			}
		};

		public static void SetupSacrificeData()
		{
			AllSacrifices = DefaultSacrifices;
			try
			{
				UpdateYamlConfig(File.ReadAllText(ValConfig.sacrificeCfgPath));
			}
			catch (Exception arg)
			{
				AllSacrifices = DefaultSacrifices;
				Logger.LogWarning($"There was an error updating the Sacrifice Data, defaults will be used. Exception: {arg}");
			}
		}

		public static string YamlDefaultConfig()
		{
			return DataObjects.yamlserializer.Serialize((object)DefaultSacrifices);
		}

		public static bool UpdateYamlConfig(string yaml)
		{
			try
			{
				AllSacrifices = DataObjects.yamldeserializer.Deserialize<Dictionary<Deities.Deity, Dictionary<string, DataObjects.Sacrifice>>>(yaml);
				Logger.LogDebug("Loaded new Sacrifice Data.");
			}
			catch (Exception ex)
			{
				Logger.LogError("Failed to parse Sacrifices.yaml YAML: " + ex.Message);
				return false;
			}
			return true;
		}
	}
	public class ValConfig
	{
		[CompilerGenerated]
		private sealed class <OnClientReceivePrestigeConfigs>d__27 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public long sender;

			public ZPackage package;

			private string <yaml>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <OnClientReceivePrestigeConfigs>d__27(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<yaml>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<yaml>5__1 = package.ReadString();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <OnServerRecieveConfigs>d__28 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public long sender;

			public ZPackage package;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <OnServerRecieveConfigs>d__28(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static ConfigFile cfg;

		public static ConfigEntry<bool> EnableDebugMode;

		public static ConfigEntry<string> TributeLocationBiome;

		public static ConfigEntry<int> MaxMeadowsLocations;

		public static ConfigEntry<int> MaxBlackForestLocations;

		public static ConfigEntry<int> MaxSwampLocations;

		public static ConfigEntry<int> MaxMountainLocations;

		public static ConfigEntry<int> MaxPlainsLocations;

		public static ConfigEntry<int> MaxMistlandsLocations;

		public static ConfigEntry<int> MaxAshlandsLocations;

		public static ConfigEntry<float> MinDistanceBetweenTributeLocations;

		public static ConfigEntry<float> ChanceOfHarvestBonusBoon;

		public static ConfigEntry<bool> KeyRequirementsHideChoices;

		public static ConfigEntry<bool> BoonRequirementsHideChoices;

		public static ConfigEntry<bool> OathRequirementsHideChoices;

		public static ConfigEntry<float> LocalLevelDisplayOffset;

		public const string cfgFolder = "ValhallaEternal";

		private const string sacrificeyml = "Sacrifices.yaml";

		internal static string sacrificeCfgPath = Path.Combine(Paths.ConfigPath, "ValhallaEternal", "Sacrifices.yaml");

		private static CustomRPC prestigeRPC;

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

		public static string GetSecondaryConfigDirectoryPath()
		{
			string path = Path.Combine(Paths.ConfigPath, "ValhallaEternal");
			DirectoryInfo directoryInfo = Directory.CreateDirectory(path);
			return directoryInfo.FullName;
		}

		public void SetupConfigRPCs()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0028: Expected O, but got Unknown
			prestigeRPC = NetworkManager.Instance.AddRPC("VALHALL_PRESTIGE", new CoroutineHandler(OnServerRecieveConfigs), new CoroutineHandler(OnClientReceivePrestigeConfigs));
			SynchronizationManager.Instance.AddInitialSynchronization(prestigeRPC, (Func<ZPackage>)SendSacrificeData);
		}

		private void CreateConfigValues(ConfigFile Config)
		{
			//IL_01c2: 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_01d4: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Expected O, but got Unknown
			MaxMeadowsLocations = BindServerConfig("TributeLocations", "MaxMeadowsLocations", 10, "The maximum number of tribute locations that the world generator will try to place, these are not gaurenteed.", advanced: false, 0, 50);
			MaxBlackForestLocations = BindServerConfig("TributeLocations", "MaxBlackForestLocations", 15, "The maximum number of tribute locations that the world generator will try to place, these are not gaurenteed.", advanced: false, 0, 50);
			MaxSwampLocations = BindServerConfig("TributeLocations", "MaxSwampLocations", 15, "The maximum number of tribute locations that the world generator will try to place, these are not gaurenteed.", advanced: false, 0, 50);
			MaxMountainLocations = BindServerConfig("TributeLocations", "MaxMountainLocations", 15, "The maximum number of tribute locations that the world generator will try to place, these are not gaurenteed.", advanced: false, 0, 50);
			MaxPlainsLocations = BindServerConfig("TributeLocations", "MaxPlainsLocations", 15, "The maximum number of tribute locations that the world generator will try to place, these are not gaurenteed.", advanced: false, 0, 50);
			MaxMistlandsLocations = BindServerConfig("TributeLocations", "MaxMistlandsLocations", 15, "The maximum number of tribute locations that the world generator will try to place, these are not gaurenteed.", advanced: false, 0, 50);
			MaxAshlandsLocations = BindServerConfig("TributeLocations", "MaxAshlandsLocations", 7, "The maximum number of tribute locations that the world generator will try to place, these are not gaurenteed.", advanced: false, 0, 50);
			MinDistanceBetweenTributeLocations = BindServerConfig("TributeLocations", "MinDistanceBetweenTributeLocations", 700f, "The minimum distance between any tribute locations. Larger values make this more spread out.", advanced: false, 0f, 5000f);
			LocalLevelDisplayOffset = BindServerConfig("LevelDisplay", "LocalLevelDisplayOffset", 50f, "The x pixel offset for the local players level display.");
			KeyRequirementsHideChoices = BindServerConfig("Discovery", "KeyRequirementsHideChoices", value: true, "Whether or not required global or private keys cause options to be hidden if not met.");
			BoonRequirementsHideChoices = BindServerConfig("Discovery", "BoonRequirementsHideChoices", value: true, "Whether or not required Boons cause options to be hidden if not met.");
			OathRequirementsHideChoices = BindServerConfig("Discovery", "OathRequirementsHideChoices", value: true, "Whether or not required Oaths cause options to be hidden if not met.");
			ChanceOfHarvestBonusBoon = BindServerConfig("Boons", "ChanceOfHarvestBonusBoon", 0.1f, "Chance that the harvest boon will activate when the player has it.", advanced: false, 0.001f, 1f);
			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 secondaryConfigDirectoryPath = GetSecondaryConfigDirectoryPath();
			string[] files = Directory.GetFiles(secondaryConfigDirectoryPath);
			bool flag = false;
			string[] array = files;
			foreach (string text in array)
			{
				if (text.Contains("Sacrifices.yaml"))
				{
					Logger.LogDebug("Found Sacrifice configurations: " + text);
					sacrificeCfgPath = text;
					flag = true;
				}
			}
			if (!flag)
			{
				Logger.LogDebug("Sacrifice Configs missing, recreating.");
				using StreamWriter streamWriter = new StreamWriter(sacrificeCfgPath);
				string value = "#################################################\r\n# Valhalla Eternal Sacrifices Configuration File\r\n#################################################\r\n";
				streamWriter.WriteLine(value);
				streamWriter.WriteLine(SacrificeData.YamlDefaultConfig());
			}
			SetupFileWatcher("Sacrifices.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.LogInfo("Player is not an admin, and not allowed to change local configuration. Ignoring.");
			}
			else if (File.Exists(e.FullPath))
			{
				string yaml = File.ReadAllText(e.FullPath);
				FileInfo fileInfo = new FileInfo(e.FullPath);
				Logger.LogDebug("Filewatch changes from: (" + fileInfo.Name + ") " + fileInfo.FullName);
				string name = fileInfo.Name;
				string text = name;
				if (text == "Sacrifices.yaml")
				{
					Logger.LogDebug("Triggering Sacrifice config reload.");
					SacrificeData.UpdateYamlConfig(yaml);
					prestigeRPC.SendPackage(ZNet.instance.m_peers, SendFileAsZPackage(e.FullPath));
				}
			}
		}

		[IteratorStateMachine(typeof(<OnClientReceivePrestigeConfigs>d__27))]
		private static IEnumerator OnClientReceivePrestigeConfigs(long sender, ZPackage package)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnClientReceivePrestigeConfigs>d__27(0)
			{
				sender = sender,
				package = package
			};
		}

		[IteratorStateMachine(typeof(<OnServerRecieveConfigs>d__28))]
		private static IEnumerator OnServerRecieveConfigs(long sender, ZPackage package)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnServerRecieveConfigs>d__28(0)
			{
				sender = sender,
				package = package
			};
		}

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

		private static ZPackage SendSacrificeData()
		{
			return SendFileAsZPackage(sacrificeCfgPath);
		}

		public static ConfigEntry<bool> BindServerConfig(string catagory, string key, bool value, string description, AcceptableValueBase acceptableValues = null, bool advanced = false)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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
			} }));
		}
	}
}
namespace ValhallEternal.boons
{
	internal static class BasicProtection
	{
		[HarmonyPatch(typeof(Player), "GetBodyArmor")]
		private static class BodyArmor
		{
			private static void Postfix(ref float __result)
			{
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.BasicProtection, out var value))
				{
					__result += value;
				}
			}
		}
	}
	internal static class BonusSkillXP
	{
		[HarmonyPatch(typeof(Player))]
		public static class IncreaseFoodValue
		{
			[HarmonyPostfix]
			[HarmonyPatch("RaiseSkill")]
			public static void ChanceBonus(Player __instance, SkillType skill)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				if (!RaiseActive && PlayerData.HasBoonWithValue(DataObjects.Boons.RandomXPBonus, out var value))
				{
					int num = Random.Range(0, 100);
					if (value >= (float)num)
					{
						((Character)__instance).RaiseSkill(skill, value);
						RaiseActive = true;
						Logger.LogDebug($"[RaiseSkillChanceXP] giving XP for {skill} {value}");
					}
				}
				RaiseActive = false;
			}
		}

		private static bool RaiseActive;
	}
	internal static class BuiltDifferent
	{
		private static class BuiltDifferentStagger
		{
			[HarmonyPatch("GetStaggerTreshold")]
			private static void Postfix(Character __instance, ref float __result)
			{
				if ((Object)(object)((__instance is Player) ? __instance : null) == (Object)(object)Player.m_localPlayer && PlayerData.HasBoonWithValue(DataObjects.Boons.BuiltDifferent, out var value))
				{
					float num = 1f + (100f + value * 2f) / 100f;
					__result *= num;
					Logger.LogDebug($"[BuiltDifferent] modifying stagger threshold by x{num}");
				}
			}
		}
	}
	internal static class FishingProsperity
	{
		public class FishReward : DataObjects.IProbability
		{
			public float SelectionWeight { get; set; }

			public int MinLevelRequired { get; set; }

			public int MaxLevelAllowed { get; set; }

			public int RewardCountMax { get; set; }

			public int RewardsCountMin { get; set; }

			public string Name { get; set; }
		}

		[HarmonyPatch(typeof(FishingFloat), "Catch")]
		public static class IncreaseHarvestYieldsFromDiety
		{
			public static void Prefix(Fish fish, Character owner)
			{
				//IL_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)Player.m_localPlayer != (Object)null) || !((Object)(object)owner == (Object)(object)Player.m_localPlayer) || !PlayerData.HasBoonWithValue(DataObjects.Boons.FishingProsperity, out var value))
				{
					return;
				}
				int num = Random.Range(0, 100);
				Logger.LogDebug($"Rolling chance for fishing prosperity {num} activate? {(float)num < value}");
				if ((float)num < value)
				{
					List<FishReward> source = FishingProsperityOptions.Where((FishReward x) => (float)x.MinLevelRequired < value && (float)x.MaxLevelAllowed >= value).ToList();
					string selected = Extensions.RandomSelectFromWeightedListWithExclusions(source.Cast<DataObjects.IProbability>().ToList());
					FishReward fishReward = FishingProsperityOptions.Where((FishReward x) => x.Name == selected).First();
					if (Deities.DeityEffects.ContainsKey("leafburstverticle"))
					{
						Object.Instantiate<GameObject>(Deities.DeityEffects["leafburstverticle"], ((Component)fish).transform.position, Quaternion.identity);
					}
					int num2 = Random.Range(fishReward.RewardsCountMin, fishReward.RewardCountMax);
					GameObject prefab = PrefabManager.Instance.GetPrefab(fishReward.Name);
					ItemDrop component = prefab.GetComponent<ItemDrop>();
					DamageText.instance.ShowText((TextType)7, ((Component)fish).transform.position + Vector3.up * 0.2f, $"+{num2} {Localization.instance.Localize(component.m_itemData.m_shared.m_name)}", true);
					((Humanoid)Player.m_localPlayer).m_inventory.AddItem(prefab, num2);
				}
			}
		}

		private static readonly List<FishReward> FishingProsperityOptions = new List<FishReward>
		{
			new FishReward
			{
				Name = "Flint",
				SelectionWeight = 15f,
				MinLevelRequired = 1,
				MaxLevelAllowed = 5,
				RewardCountMax = 3,
				RewardsCountMin = 1
			},
			new FishReward
			{
				Name = "SerpentScale",
				SelectionWeight = 1f,
				MinLevelRequired = 5,
				MaxLevelAllowed = 100,
				RewardCountMax = 3,
				RewardsCountMin = 1
			},
			new FishReward
			{
				Name = "Coin",
				SelectionWeight = 5f,
				MinLevelRequired = 1,
				MaxLevelAllowed = 100,
				RewardCountMax = 50,
				RewardsCountMin = 1
			},
			new FishReward
			{
				Name = "Ruby",
				SelectionWeight = 4f,
				MinLevelRequired = 5,
				MaxLevelAllowed = 100,
				RewardCountMax = 1,
				RewardsCountMin = 1
			},
			new FishReward
			{
				Name = "Amber",
				SelectionWeight = 4f,
				MinLevelRequired = 5,
				MaxLevelAllowed = 100,
				RewardCountMax = 1,
				RewardsCountMin = 1
			},
			new FishReward
			{
				Name = "AmberPearl",
				SelectionWeight = 3f,
				MinLevelRequired = 10,
				MaxLevelAllowed = 100,
				RewardCountMax = 1,
				RewardsCountMin = 1
			},
			new FishReward
			{
				Name = "SilverNecklace",
				SelectionWeight = 2f,
				MinLevelRequired = 15,
				MaxLevelAllowed = 100,
				RewardCountMax = 1,
				RewardsCountMin = 1
			}
		};
	}
	internal static class HastenTheInevitable
	{
		[HarmonyPatch(typeof(Character), "OnDeath")]
		private static class HastenOnKill
		{
			private static void Prefix(Character __instance)
			{
				if (__instance.m_lastHit != null && (Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)__instance.m_lastHit.GetAttacker() == (Object)(object)Player.m_localPlayer && PlayerData.HasBoonWithValue(DataObjects.Boons.HastenTheInevitable, out var _))
				{
					((Character)Player.m_localPlayer).GetSEMan().AddStatusEffect(hastenDeathBringerEffectID, true, 0, 0f);
				}
			}
		}

		private static int hastenDeathBringerEffectID;

		internal static void AddHastenDeathStatus()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			SE_Stats val = ScriptableObject.CreateInstance<SE_Stats>();
			val.m_speedModifier = 1.3f;
			((Object)val).name = "HastenDeathEffect";
			((StatusEffect)val).m_name = "$ve_hasten_death_effect";
			((StatusEffect)val).m_icon = DataObjects.hastenDeath;
			((StatusEffect)val).m_ttl = 5f;
			CustomStatusEffect val2 = new CustomStatusEffect((StatusEffect)(object)val, false);
			ItemManager.Instance.AddStatusEffect(val2);
			hastenDeathBringerEffectID = val2.StatusEffect.NameHash();
		}
	}
	internal static class HellfireAdaptation
	{
		[HarmonyPatch(typeof(Player), "GetEquipmentHeatResistanceModifier")]
		private static class HellfireHeatResist
		{
			private static void Postfix(Player __instance, ref float __result)
			{
				if (!((Object)(object)__instance == (Object)null) && PlayerData.HasBoonWithValue(DataObjects.Boons.IncreaseHeatResistance, out var value))
				{
					__result += (100f + value) / 100f;
				}
			}
		}
	}
	internal static class IncreaseDamageConditional
	{
		[HarmonyPatch(typeof(Character))]
		public static class ModifyAttackDamages
		{
			private static float perfectFormCharge;

			private static int arrowCatcherCharge;

			[HarmonyPrefix]
			[HarmonyPatch("RPC_Damage")]
			public static void ModifyAttackDamage(Character __instance, HitData hit)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Invalid comparison between Unknown and I4
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				Character attacker = hit.GetAttacker();
				if ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)((attacker is Player) ? attacker : null) == (Object)(object)Player.m_localPlayer)
				{
					if ((int)__instance.m_faction == 3 && PlayerData.HasBoonWithValue(DataObjects.Boons.DamageAgainstUndead, out var value))
					{
						float num = 1f + (100f + value) / 100f;
						((DamageTypes)(ref hit.m_damage)).Modify(num);
						Logger.LogDebug($"[IncreaseDamageAgainstUndead] modifying hit by x{num}");
					}
					if (EnvMan.IsNight() && PlayerData.HasBoonWithValue(DataObjects.Boons.StormboundRage, out var value2))
					{
						float num2 = hit.m_damage.GetTotalDamageNoHarvestValues() * ((100f + value2) / 100f);
						hit.m_damage.m_lightning += num2;
						Logger.LogDebug($"[StormboundRage] adding {num2} lightning damage.");
					}
					if (PlayerData.HasBoonWithValue(DataObjects.Boons.DedicationToTheBlade, out var value3))
					{
						if (!hit.m_ranged)
						{
							float num3 = 1f + (100f + value3) / 100f;
							((DamageTypes)(ref hit.m_damage)).Modify(num3);
							Logger.LogDebug($"[DedicationToTheBlade] modifying hit by x{num3}.");
						}
						else
						{
							float num4 = (100f - value3 * 2f) / 100f;
							if (num4 < 0f)
							{
								num4 = 0f;
							}
							((DamageTypes)(ref hit.m_damage)).Modify(num4);
							Logger.LogDebug($"[DedicationToTheBlade] modifying hit by x{num4}.");
						}
					}
					if (PlayerData.HasBoonWithValue(DataObjects.Boons.PerfectForm, out var value4))
					{
						float num5 = 1f + (100f + value4) / 100f;
						perfectFormCharge += hit.GetTotalDamage() * num5;
						if (perfectFormCharge > 1000f)
						{
							float num6 = 2f + (12f + value4) / 12f;
							((DamageTypes)(ref hit.m_damage)).Modify(num6);
							perfectFormCharge = 0f;
							Logger.LogDebug($"[DedicationToTheBlade] modifying hit by x{num5}.");
						}
					}
				}
				else
				{
					if (!((Object)(object)__instance == (Object)(object)Player.m_localPlayer))
					{
						return;
					}
					if (__instance.IsStaggering() && PlayerData.HasBoonWithValue(DataObjects.Boons.Everwatchful, out var value5))
					{
						float num7 = (100f - value5 * 2f) / 100f;
						if (num7 < 0f)
						{
							num7 = 0f;
						}
						((DamageTypes)(ref hit.m_damage)).Modify(num7);
						Logger.LogDebug($"[Everwatchful] modifying hit by x{num7}.");
					}
					if (hit.m_ranged && PlayerData.HasBoonWithValue(DataObjects.Boons.ArrowCatcher, out var value6))
					{
						if (arrowCatcherCharge < 5)
						{
							arrowCatcherCharge++;
						}
						else
						{
							arrowCatcherCharge = 0;
							float num8 = (100f - value6) * 0.001f;
							if ((double)num8 < 0.1)
							{
								num8 = 0.1f;
							}
							((DamageTypes)(ref hit.m_damage)).Modify(num8);
							Logger.LogDebug($"[ArrowCatcher] reducing damage {value6}.");
						}
					}
					if (PlayerData.HasBoonWithValue(DataObjects.Boons.BalanceOfTheJotunn, out var value7))
					{
						((Character)Player.m_localPlayer).AddStamina(value7);
						Logger.LogDebug($"[BalanceOfTheJotunn] providing stamina {value7}.");
					}
					if (PlayerData.HasBoonWithValue(DataObjects.Boons.BalanceOfTheAesir, out var value8))
					{
						((Character)Player.m_localPlayer).AddEitr(value8);
						Logger.LogDebug($"[BalanceOfTheAesir] providing eitr {value7}.");
					}
				}
			}
		}
	}
	internal static class IncreasePickableYield
	{
		[HarmonyPatch(typeof(Pickable), "Interact")]
		public static class IncreaseHarvestYieldsFromDiety
		{
			private static uint lastpicked;

			public static void Prefix(Pickable __instance, Humanoid character)
			{
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: 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_01cc: 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_01dc: 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_0191: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_020d: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.m_picked)
				{
					return;
				}
				if (UnallowedPickables.Contains(((Object)__instance.m_itemPrefab).name))
				{
					Logger.LogDebug("Pickable is not a gathering item.");
					return;
				}
				Logger.LogDebug($"Checking if player has pickable {PlayerData.localPlayerConfig.HasBoon(DataObjects.Boons.IncreasePickableYields, out var BoonValue)} - {BoonValue}");
				if (!PlayerData.localPlayerConfig.HasBoon(DataObjects.Boons.IncreasePickableYields, out var BoonValue2))
				{
					return;
				}
				uint num = 0u;
				if (__instance.m_nview.GetZDO() != null)
				{
					num = ((ZDOID)(ref __instance.m_nview.GetZDO().m_uid)).ID;
				}
				if (num == lastpicked)
				{
					return;
				}
				if (Random.value <= ValConfig.ChanceOfHarvestBonusBoon.Value)
				{
					Logger.LogDebug("Failed chance roll for pickable bonus");
					return;
				}
				lastpicked = num;
				float num2 = Random.Range(1f, 10f);
				int num3 = 1;
				if (num2 >= BoonValue2)
				{
					num3 = Mathf.RoundToInt(num2 / BoonValue2);
				}
				if (num3 > 0)
				{
					Vector3 val = ((Component)__instance).transform.position + Vector3.up * __instance.m_spawnOffset;
					Logger.LogDebug($"Spawning extra drops {num3}");
					if (Deities.DeityEffects.ContainsKey("leafburstverticle"))
					{
						GameObject val2 = Object.Instantiate<GameObject>(Deities.DeityEffects["leafburstverticle"], val, Quaternion.identity);
						Transform transform = val2.transform;
						transform.localScale *= 2f;
					}
					DamageText.instance.ShowText((TextType)4, ((Component)__instance).transform.position + Vector3.up * __instance.m_spawnOffset, $"{num3}", true);
					for (int i = 0; i < num3; i++)
					{
						Object.Instantiate<GameObject>(__instance.m_itemPrefab, val, ((Component)__instance).transform.rotation);
					}
				}
			}
		}

		private static readonly List<string> UnallowedPickables = new List<string>
		{
			"SurtlingCore", "Flint", "Wood", "Branch", "Stone", "Amber", "AmberPearl", "Coins", "Ruby", "CryptRemains",
			"Obsidian", "Crystal", "Pot_Shard", "DragonEgg", "DvergrLantern", "DvergrMineTreasure", "SulfurRock", "VoltureEgg", "Swordpiece", "MoltenCore",
			"Hairstrands", "Tar", "BlackCore"
		};
	}
	internal static class IncreaseRegens
	{
		[HarmonyPatch(typeof(SEMan))]
		private static class IncreaseAllRegenTypes
		{
			[HarmonyPostfix]
			[HarmonyPatch("ModifyHealthRegen")]
			private static void ModifyHealthRegen(ref float regenMultiplier)
			{
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.GoddessOfWar, out var value))
				{
					float num = 1f + (100f + value) / 100f;
					regenMultiplier *= num;
				}
			}

			[HarmonyPostfix]
			[HarmonyPatch("ModifyStaminaRegen")]
			private static void ModifyStaminaRegen(ref float staminaMultiplier)
			{
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.GoddessOfWar, out var value))
				{
					float num = 1f + (100f + value) / 100f;
					staminaMultiplier *= num;
				}
			}

			[HarmonyPostfix]
			[HarmonyPatch("ModifyEitrRegen")]
			private static void ModifyEitrRegen(ref float eitrMultiplier)
			{
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.SeidrOfPlenty, out var value))
				{
					float num = 1f + (100f + value) / 100f;
					eitrMultiplier *= num;
				}
			}
		}
	}
	internal static class KnowledgeIsPower
	{
		[HarmonyPatch(typeof(Player))]
		public static class CheckForIncreaseToBonus
		{
			[HarmonyPostfix]
			[HarmonyPatch("RaiseSkill")]
			public static void CheckSkillLevelBonus(Player __instance, SkillType skill)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				if (CombatSkills.Contains(skill) || !PlayerData.HasBoonWithValue(DataObjects.Boons.KnowledgeIsPower, out var value))
				{
					return;
				}
				float num = 0f;
				foreach (SkillDef skill2 in ((Character)__instance).GetSkills().m_skills)
				{
					if (!CombatSkills.Contains(skill2.m_skill))
					{
						float skillLevel = ((Character)Player.m_localPlayer).GetSkillLevel(skill2.m_skill);
						if (skillLevel > num)
						{
							num = skillLevel;
						}
					}
				}
				CurrentBonus = 1f + num * ((100f + value) / 100f);
			}
		}

		[HarmonyPatch]
		public static class ApplySkillBonusFactor
		{
			[HarmonyPostfix]
			[HarmonyPatch(typeof(SEMan), "ModifySkillLevel")]
			public static void ProvideSkillLevelBonus(SkillType skill, ref float level)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				if (PlayerData.HasBoon(DataObjects.Boons.KnowledgeIsPower) && CombatSkills.Contains(skill) && CurrentBonus > 0f)
				{
					level *= CurrentBonus;
				}
			}
		}

		private static readonly List<SkillType> CombatSkills = new List<SkillType>
		{
			(SkillType)1,
			(SkillType)2,
			(SkillType)3,
			(SkillType)4,
			(SkillType)5,
			(SkillType)7,
			(SkillType)8,
			(SkillType)14,
			(SkillType)11
		};

		public static float CurrentBonus = 0f;

		public static int SkillLevelReckFrequency = 10;
	}
	internal static class ModifyHealthEitirStam
	{
		[HarmonyPatch(typeof(Player))]
		public static class IncreaseFoodValue
		{
			[HarmonyPostfix]
			[HarmonyPatch("GetTotalFoodValue")]
			public static void IncreaseTotalValue(Player __instance, ref float hp, ref float stamina, ref float eitr)
			{
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.QualityNourishment, out var value))
				{
					float num = 1f + value / 100f;
					hp *= num;
					stamina *= num;
					eitr *= num;
				}
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.IncreaseBaseEitr, out var value2))
				{
					eitr += value2;
				}
			}

			[HarmonyPostfix]
			[HarmonyPatch("GetBaseFoodHP")]
			public static void IncreaseHPValue(Player __instance, ref float __result)
			{
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.QualityNourishment, out var value))
				{
					float num = 1f + value / 100f;
					__result *= num;
				}
			}

			[HarmonyPostfix]
			[HarmonyPatch(typeof(Player), "EatFood")]
			public static void NatureEffectOnFoodEat()
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				if (PlayerData.HasBoon(DataObjects.Boons.QualityNourishment) && Deities.DeityEffects.ContainsKey("leafburstverticle") && (Object)(object)Player.m_localPlayer != (Object)null)
				{
					GameObject val = Object.Instantiate<GameObject>(Deities.DeityEffects["leafburstverticle"], ((Component)Player.m_localPlayer).transform.position, Quaternion.identity);
					Transform transform = val.transform;
					transform.localScale *= 3f;
				}
			}
		}
	}
	internal class NightSwiftness
	{
		[HarmonyPatch(typeof(Character))]
		public static class RunningSpeedPatch
		{
			[HarmonyPatch("GetRunSpeedFactor")]
			private static void Postfix(Character __instance, ref float __result)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Invalid comparison between Unknown and I4
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Invalid comparison between Unknown and I4
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.SwiftShadow, out var value) && (Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)__instance == (Object)(object)Player.m_localPlayer && ((int)Player.m_localPlayer.m_currentBiome == 64 || (int)Player.m_localPlayer.m_currentBiome == 4 || EnvMan.IsNight()))
				{
					float num = 0.1f + value * 0.01f;
					float num2 = __instance.m_runSpeed + num;
					__result = num2;
				}
			}
		}
	}
	internal static class RecipeGainBonus
	{
		[HarmonyPatch(typeof(Player))]
		public static class IncreaseFoodValue
		{
			[HarmonyPostfix]
			[HarmonyPatch("AddKnownRecipe")]
			public static void ThirstForKnowledgeXPGain(Player __instance)
			{
				//IL_004a: 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_005b: Unknown result type (might be due to invalid IL or missing references)
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.HungerForKnowledge, out var value))
				{
					int num = Random.Range(0, 100);
					if ((float)num <= value)
					{
						SkillType[] array = (SkillType[])Enum.GetValues(typeof(SkillType));
						SkillType val = array[Random.Range(0, array.Length - 1)];
						((Character)__instance).RaiseSkill(val, value);
						Logger.LogDebug($"[HungerForKnowledgeXPGain] giving XP for {val} {value}");
					}
				}
			}
		}
	}
	internal static class ReduceFirePoison
	{
		[HarmonyPatch(typeof(Character), "AddFireDamage")]
		private static class ReduceFireDamageApplied
		{
			private static void Prefix(Character __instance, ref float damage)
			{
				if ((Object)(object)__instance != (Object)null && (Object)(object)((__instance is Player) ? __instance : null) == (Object)(object)Player.m_localPlayer && PlayerData.HasBoonWithValue(DataObjects.Boons.ReduceFirePoison, out var value))
				{
					float num = 1f - (100f - value) * 0.001f;
					if ((double)num < 0.2)
					{
						num = 0.2f;
					}
					Logger.LogDebug($"[ReduceFirePoison] is reducing Fire {damage} by {num * 100f}% = ({damage * num})");
					damage *= num;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "AddPoisonDamage")]
		private static class ReducePoisonDamageApplied
		{
			private static void Prefix(Character __instance, ref float damage)
			{
				if ((Object)(object)__instance != (Object)null && (Object)(object)((__instance is Player) ? __instance : null) == (Object)(object)Player.m_localPlayer && PlayerData.HasBoonWithValue(DataObjects.Boons.ReduceFirePoison, out var value))
				{
					float num = 1f - (100f - value) * 0.001f;
					if ((double)num < 0.2)
					{
						num = 0.2f;
					}
					Logger.LogDebug($"[ReduceFirePoison] is reducing Poison {damage} by {num * 100f}% = ({damage * num})");
					damage *= num;
				}
			}
		}
	}
	internal static class ScavangeOnKill
	{
		public class LootReward : DataObjects.IProbability
		{
			public float SelectionWeight { get; set; }

			public int MinLevelRequired { get; set; }

			public int MaxLevelAllowed { get; set; }

			public int MinDropAmount { get; set; }

			public int MaxDropAmount { get; set; }

			public float ChanceForDropIncrease { get; set; }

			public string Name { get; set; }
		}

		[HarmonyPatch]
		private static class OnKillLootBonuses
		{
			[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
			private static void Postfix(CharacterDrop __instance)
			{
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0344: Unknown result type (might be due to invalid IL or missing references)
				//IL_0349: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_043a: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.m_character.IsTamed())
				{
					return;
				}
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.HuntressArrowReturn, out var arrowReturnVal))
				{
					float num = Random.Range(0, 100);
					float num2 = arrowReturnVal;
					if (num2 > 10f)
					{
						num2 = 10f;
					}
					Logger.LogDebug($"[HuntressArrowReturn] Roll: {num} <= {num2} | {num <= num2}");
					if (num <= num2)
					{
						List<LootReward> source = ArrowReturnProbabilityRewards.Where((LootReward x) => (float)x.MinLevelRequired < arrowReturnVal && (float)x.MaxLevelAllowed >= arrowReturnVal).ToList();
						string selected2 = Extensions.RandomSelectFromWeightedListWithExclusions(source.Cast<DataObjects.IProbability>().ToList());
						Logger.LogDebug("Selected Reward " + selected2);
						List<LootReward> list = ArrowReturnProbabilityRewards.Where((LootReward x) => x.Name == selected2).ToList();
						if (list.Count > 0)
						{
							if (Deities.DeityEffects.ContainsKey("snowswirl"))
							{
								Object.Instantiate<GameObject>(Deities.DeityEffects["snowswirl"], ((Component)Player.m_localPlayer).transform.position, Quaternion.identity);
							}
							GameObject prefab = PrefabManager.Instance.GetPrefab(list.First().Name);
							ItemDrop component = prefab.GetComponent<ItemDrop>();
							DamageText.instance.ShowText((TextType)7, ((Component)Player.m_localPlayer).transform.position + Vector3.up * 0.2f, "+1 " + Localization.instance.Localize(component.m_itemData.m_shared.m_name), true);
							Logger.LogDebug("[HuntressArrowReturn] providing +1 " + component.m_itemData.m_shared.m_name);
							((Humanoid)Player.m_localPlayer).m_inventory.AddItem(prefab, 1);
						}
					}
				}
				if (!PlayerData.HasBoonWithValue(DataObjects.Boons.WealthOfAges, out var wealthValue))
				{
					return;
				}
				float num3 = Random.Range(0, 100);
				float num4 = arrowReturnVal;
				if (num4 > 10f)
				{
					num4 = 10f;
				}
				Logger.LogDebug($"[WealthOfAges] Roll: {num3} <= {num4} | {num3 <= num4}");
				if (!(num3 <= num4))
				{
					return;
				}
				List<LootReward> source2 = WealthProbabilityRewards.Where((LootReward x) => (float)x.MinLevelRequired < wealthValue && (float)x.MaxLevelAllowed >= wealthValue).ToList();
				string selected = Extensions.RandomSelectFromWeightedListWithExclusions(source2.Cast<DataObjects.IProbability>().ToList());
				Logger.LogDebug("Selected Reward " + selected);
				List<LootReward> list2 = ArrowReturnProbabilityRewards.Where((LootReward x) => x.Name == selected).ToList();
				if (list2.Count <= 0)
				{
					return;
				}
				LootReward lootReward = list2.First();
				if (Deities.DeityEffects.ContainsKey("goldenswirl"))
				{
					Object.Instantiate<GameObject>(Deities.DeityEffects["goldenswirl"], ((Component)__instance).transform.position, Quaternion.identity);
				}
				int i;
				for (i = lootReward.MinDropAmount; i < lootReward.MaxDropAmount; i++)
				{
					if (!((float)Random.Range(0, 100) < lootReward.ChanceForDropIncrease))
					{
						break;
					}
				}
				GameObject prefab2 = PrefabManager.Instance.GetPrefab(lootReward.Name);
				ItemDrop component2 = prefab2.GetComponent<ItemDrop>();
				DamageText.instance.ShowText((TextType)7, ((Component)Player.m_localPlayer).transform.position + Vector3.up * 0.2f, "+1 " + Localization.instance.Localize(component2.m_itemData.m_shared.m_name), true);
				Logger.LogDebug($"[WealthOfAges] providing +{i} {((Object)prefab2).name}");
				Extensions.DropItemsImmediate(new Dictionary<GameObject, int> { { prefab2, i } }, ((Component)__instance).transform.position, 0.5f);
			}
		}

		private static readonly List<LootReward> ArrowReturnProbabilityRewards = new List<LootReward>
		{
			new LootReward
			{
				Name = "ArrowWood",
				SelectionWeight = 5f,
				MinLevelRequired = 1,
				MaxLevelAllowed = 10
			},
			new LootReward
			{
				Name = "ArrowFlint",
				SelectionWeight = 5f,
				MinLevelRequired = 5,
				MaxLevelAllowed = 20
			},
			new LootReward
			{
				Name = "ArrowBronze",
				SelectionWeight = 5f,
				MinLevelRequired = 10,
				MaxLevelAllowed = 35
			},
			new LootReward
			{
				Name = "ArrowFire",
				SelectionWeight = 5f,
				MinLevelRequired = 15,
				MaxLevelAllowed = 40
			},
			new LootReward
			{
				Name = "ArrowIron",
				SelectionWeight = 4f,
				MinLevelRequired = 20,
				MaxLevelAllowed = 50
			},
			new LootReward
			{
				Name = "ArrowPoison",
				SelectionWeight = 4f,
				MinLevelRequired = 25,
				MaxLevelAllowed = 55
			},
			new LootReward
			{
				Name = "ArrowObsidian",
				SelectionWeight = 4f,
				MinLevelRequired = 30,
				MaxLevelAllowed = 60
			},
			new LootReward
			{
				Name = "ArrowFrost",
				SelectionWeight = 3f,
				MinLevelRequired = 35,
				MaxLevelAllowed = 65
			},
			new LootReward
			{
				Name = "ArrowSilver",
				SelectionWeight = 3f,
				MinLevelRequired = 40,
				MaxLevelAllowed = 70
			},
			new LootReward
			{
				Name = "ArrowNeedle",
				SelectionWeight = 2f,
				MinLevelRequired = 45,
				MaxLevelAllowed = 75
			},
			new LootReward
			{
				Name = "ArrowCarapace",
				SelectionWeight = 2f,
				MinLevelRequired = 50,
				MaxLevelAllowed = 80
			},
			new LootReward
			{
				Name = "ArrowCharred",
				SelectionWeight = 1f,
				MinLevelRequired = 55,
				MaxLevelAllowed = 100
			}
		};

		private static readonly List<LootReward> WealthProbabilityRewards = new List<LootReward>
		{
			new LootReward
			{
				Name = "Coin",
				SelectionWeight = 5f,
				MinLevelRequired = 1,
				MaxLevelAllowed = 10,
				MinDropAmount = 1,
				MaxDropAmount = 25,
				ChanceForDropIncrease = 0.1f
			},
			new LootReward
			{
				Name = "Coin",
				SelectionWeight = 5f,
				MinLevelRequired = 10,
				MaxLevelAllowed = 100,
				MinDropAmount = 3,
				MaxDropAmount = 25,
				ChanceForDropIncrease = 0.3f
			},
			new LootReward
			{
				Name = "Ruby",
				SelectionWeight = 4f,
				MinLevelRequired = 15,
				MaxLevelAllowed = 100,
				MinDropAmount = 1,
				MaxDropAmount = 7,
				ChanceForDropIncrease = 0.05f
			},
			new LootReward
			{
				Name = "Amber",
				SelectionWeight = 4f,
				MinLevelRequired = 20,
				MaxLevelAllowed = 100,
				MinDropAmount = 1,
				MaxDropAmount = 8,
				ChanceForDropIncrease = 0.05f
			},
			new LootReward
			{
				Name = "AmberPearl",
				SelectionWeight = 3f,
				MinLevelRequired = 25,
				MaxLevelAllowed = 100,
				MinDropAmount = 1,
				MaxDropAmount = 5,
				ChanceForDropIncrease = 0.05f
			},
			new LootReward
			{
				Name = "SilverNecklace",
				SelectionWeight = 2f,
				MinLevelRequired = 30,
				MaxLevelAllowed = 100,
				MinDropAmount = 1,
				MaxDropAmount = 3,
				ChanceForDropIncrease = 0.05f
			}
		};
	}
	internal static class StrongerBlock
	{
		[HarmonyPatch(typeof(ItemData), "GetBaseBlockPower", new Type[] { typeof(int) })]
		private static class StrongerShieldBlock
		{
			private static void Postfix(ItemData __instance, ref float __result)
			{
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.PowerfulShield, out var value))
				{
					float num = 1f + (100f + value) / 100f;
					__result *= num;
				}
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.StrongerTowerBlock, out var value2) && __instance.m_shared.m_timedBlockBonus == 0f)
				{
					float num2 = 1f + (100f + value2) / 100f;
					__result *= num2;
				}
			}
		}
	}
	internal static class WeaponLearning
	{
		[HarmonyPatch(typeof(Skills), "RaiseSkill")]
		internal static class WeaponSharedKnowledgePatch
		{
			public static void Prefix(Skills __instance, SkillType skillType, float factor)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				if (PlayerData.HasBoonWithValue(DataObjects.Boons.RandomXPBonus, out var value))
				{
					float num = Random.Range(0, 100);
					if (num < value)
					{
						float num2 = Random.Range(1f, value);
						Logger.LogDebug($"[WeaponSharedKnowledgePatch] Raising skill {skillType} by {num2} due to RandomXPBonus boon.");
						factor += num2;
					}
				}
			}

			public static void Postfix(Skills __instance, SkillType skillType, float factor)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				if (!WeaponsSkills.Contains(skillType) && PlayerData.HasBoonWithValue(DataObjects.Boons.BladeboundKnowledge, out var value))
				{
					float num = Random.Range(0, 100);
					if (num < value)
					{
						float num2 = Random.Range(1f, value);
						SkillType val = NonCombatSkills[Random.Range(0, NonCombatSkills.Count)];
						Logger.LogDebug($"[WeaponSharedKnowledgePatch] Raising non-weapon skill {val} by {num2} due to Bladebound Knowledge boon.");
						__instance.RaiseSkill(val, num2);
					}
				}
			}
		}

		public static readonly List<SkillType> WeaponsSkills = new List<SkillType>
		{
			(SkillType)1,
			(SkillType)3,
			(SkillType)2,
			(SkillType)14,
			(SkillType)7,
			(SkillType)8,
			(SkillType)10,
			(SkillType)108,
			(SkillType)9,
			(SkillType)4,
			(SkillType)5
		};

		public static readonly List<SkillType> NonCombatSkills = new List<SkillType>
		{
			(SkillType)102,
			(SkillType)105,
			(SkillType)104,
			(SkillType)106,
			(SkillType)107,
			(SkillType)110,
			(SkillType)101,
			(SkillType)12,
			(SkillType)13,
			(SkillType)100
		};
	}
}