Decompiled source of OdinBear v1.4.5

OdinBear.dll

Decompiled 2 weeks ago
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using CreatureManager;
using HarmonyLib;
using ItemManager;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: AssemblyFileVersion("1.2.8.0")]
[assembly: Guid("150DFDAF-FF35-4302-B2CC-BEDCE69118D5")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyProduct("OdinBear")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("https://valheim.thunderstore.io/package/OdinPlus/OdinBear")]
[assembly: AssemblyTitle("OdinBear")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.8.0")]
[module: <2913818c-be01-4025-9ad3-5a2b47c1ee2f>RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<71d11692-5705-4230-aaa2-148f6d331193>Embedded]
	internal sealed class <71d11692-5705-4230-aaa2-148f6d331193>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<71d11692-5705-4230-aaa2-148f6d331193>Embedded]
	[CompilerGenerated]
	internal sealed class <3e938731-0684-4af9-b1cb-6949668ce29c>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <3e938731-0684-4af9-b1cb-6949668ce29c>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <3e938731-0684-4af9-b1cb-6949668ce29c>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<71d11692-5705-4230-aaa2-148f6d331193>Embedded]
	internal sealed class <e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[<71d11692-5705-4230-aaa2-148f6d331193>Embedded]
	[CompilerGenerated]
	internal sealed class <2913818c-be01-4025-9ad3-5a2b47c1ee2f>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <2913818c-be01-4025-9ad3-5a2b47c1ee2f>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace OdinBear
{
	[BepInPlugin("Raelaziel.OdinBear", "OdinBear", "1.4.5")]
	[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(1)]
	[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
	[BepInIncompatibility("org.bepinex.plugins.valheim_plus")]
	public class OdinBear : BaseUnityPlugin
	{
		[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)]
		private enum Toggle
		{
			On = 1,
			Off = 0
		}

		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
		[HarmonyPatch(typeof(CookingStation))]
		public static class CookingStationPatch
		{
			private static bool ConversionAdded;

			[HarmonyPostfix]
			[HarmonyPatch("Awake")]
			public static void Awake_Postfix(CookingStation __instance)
			{
				if ((Object)(object)__instance == (Object)null)
				{
					Debug.LogError((object)"CookingStation instance is null in Awake_Postfix.");
					return;
				}
				if (__instance.m_conversion == null)
				{
					__instance.m_conversion = new List<ItemConversion>();
				}
				AddCustomConversion(__instance);
			}

			private static void AddCustomConversion(CookingStation station)
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Expected O, but got Unknown
				try
				{
					if ((Object)(object)station == (Object)null || station.m_conversion == null)
					{
						Debug.LogError((object)"CookingStation or m_conversion is null during AddCustomConversion.");
					}
					else
					{
						if (station.m_conversion.Exists([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (ItemConversion c) => ((Object)c.m_from).name == "OdinBearMeat_Raw" && ((Object)c.m_to).name == "OdinBearMeat_Cooked"))
						{
							return;
						}
						ItemConversion val = new ItemConversion
						{
							m_from = ObjectDB.instance.GetItemPrefab("OdinBearMeat_Raw").GetComponent<ItemDrop>(),
							m_to = ObjectDB.instance.GetItemPrefab("OdinBearMeat_Cooked").GetComponent<ItemDrop>(),
							m_cookTime = 25f
						};
						if ((Object)(object)val.m_from == (Object)null || (Object)(object)val.m_to == (Object)null)
						{
							Debug.LogError((object)"Could not find prefabs for 'OdinBearMeat_Raw' or 'OdinBearMeat_Cooked'.");
							return;
						}
						station.m_conversion.Add(val);
						if (!ConversionAdded)
						{
							Debug.Log((object)$"Added custom conversion: {((Object)val.m_from).name} -> {((Object)val.m_to).name} with cook time {val.m_cookTime}s.");
							ConversionAdded = true;
						}
					}
				}
				catch (Exception arg)
				{
					Debug.LogError((object)$"Exception in AddCustomConversion: {arg}");
				}
			}
		}

		private const string ModName = "OdinBear";

		private const string ModVersion = "1.4.5";

		private const string ModGUID = "Raelaziel.OdinBear";

		private static readonly ConfigSync configSync = new ConfigSync("OdinBear")
		{
			DisplayName = "OdinBear",
			CurrentVersion = "1.4.5",
			MinimumRequiredVersion = "1.4.5"
		};

		private static ConfigEntry<Toggle> serverConfigLocked = null;

		internal static Creature raeBear;

		internal static Creature raeBearPolar;

		internal static Creature raeBearBlack;

		internal static ConfigEntry<bool> ServerConfigLocked = null;

		internal static ConfigEntry<int> BearRunningSpeed = null;

		internal static ConfigEntry<int> BearHealth = null;

		internal static ConfigEntry<float> BearStamina = null;

		internal static ConfigEntry<float> BearStaminaRegen = null;

		internal static ConfigEntry<float> BearStaminaRegenHungry = null;

		internal static ConfigEntry<int> BlackBearRunningSpeed = null;

		internal static ConfigEntry<int> BlackBearHealth = null;

		internal static ConfigEntry<float> BlackBearStamina = null;

		internal static ConfigEntry<float> BlackBearStaminaRegen = null;

		internal static ConfigEntry<float> BlackBearStaminaRegenHungry = null;

		internal static ConfigEntry<int> PolarBearRunningSpeed = null;

		internal static ConfigEntry<int> PolarBearHealth = null;

		internal static ConfigEntry<float> PolarBearStamina = null;

		internal static ConfigEntry<float> PolarBearStaminaRegen = null;

		internal static ConfigEntry<float> PolarBearStaminaRegenHungry = null;

		internal static ConfigEntry<int> BearCubHealth = null;

		internal static ConfigEntry<int> BearCubGrowupTime = null;

		internal static ConfigEntry<int> BlackBearCubHealth = null;

		internal static ConfigEntry<int> BlackBearCubGrowupTime = null;

		internal static ConfigEntry<int> PolarBearCubHealth = null;

		internal static ConfigEntry<int> PolarBearCubGrowupTime = null;

		private ConfigEntry<T> config<[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)] T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, description);
			configSync.AddConfigEntry<T>(val).SynchronizedConfig = synchronizedSetting;
			return val;
		}

		private ConfigEntry<T> config<[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)] T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		public void Awake()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected O, but got Unknown
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Expected O, but got Unknown
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Expected O, but got Unknown
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Expected O, but got Unknown
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Expected O, but got Unknown
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Expected O, but got Unknown
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Expected O, but got Unknown
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Expected O, but got Unknown
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Expected O, but got Unknown
			//IL_0fb1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fb9: Unknown result type (might be due to invalid IL or missing references)
			//IL_11f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_11ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_143e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1445: Unknown result type (might be due to invalid IL or missing references)
			//IL_167d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1777: Unknown result type (might be due to invalid IL or missing references)
			//IL_1871: Unknown result type (might be due to invalid IL or missing references)
			//IL_1960: Unknown result type (might be due to invalid IL or missing references)
			Localizer.Load();
			serverConfigLocked = config("General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
			configSync.AddLockingConfigEntry<Toggle>(serverConfigLocked);
			BearRunningSpeed = config("Bear", "Running Speed", 10, new ConfigDescription("Declare running speed for Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BearHealth = config("Bear", "Health", 250, new ConfigDescription("Declare health points for Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BearStamina = config("Bear", "Stamina", 300f, new ConfigDescription("Declare stamina for Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BearStaminaRegen = config("Bear", "Stamina Regen", 3f, new ConfigDescription("Declare stamina regen for Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BearStaminaRegenHungry = config("Bear", "Stamina Regen Hungry", 1f, new ConfigDescription("Declare stamina regen when hungry for Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BlackBearRunningSpeed = config("Black Bear", "Running Speed", 10, new ConfigDescription("Declare running speed for Black Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BlackBearHealth = config("Black Bear", "Health", 50, new ConfigDescription("Declare health points for Black Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BlackBearStamina = config("Black Bear", "Stamina", 300f, new ConfigDescription("Declare stamina for Black Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BlackBearStaminaRegen = config("Black Bear", "Stamina Regen", 2f, new ConfigDescription("Declare stamina regen for Black Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BlackBearStaminaRegenHungry = config("Black Bear", "Stamina Regen Hungry", 1f, new ConfigDescription("Declare stamina regen when hungry for Black Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			PolarBearRunningSpeed = config("Polar Bear", "Running Speed", 10, new ConfigDescription("Declare running speed for Polar Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			PolarBearHealth = config("Polar Bear", "Health", 700, new ConfigDescription("Declare health points for Polar Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			PolarBearStamina = config("Polar Bear", "Stamina", 300f, new ConfigDescription("Declare stamina for Polar Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			PolarBearStaminaRegen = config("Polar Bear", "Stamina Regen", 4f, new ConfigDescription("Declare stamina regen for Polar Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			PolarBearStaminaRegenHungry = config("Polar Bear", "Stamina Regen Hungry", 1f, new ConfigDescription("Declare stamina regen when hungry for Polar Bear", (AcceptableValueBase)null, Array.Empty<object>()));
			BearCubHealth = config("Bear Cub", "Health", 60, new ConfigDescription("Declare health points for Bear Cub", (AcceptableValueBase)null, Array.Empty<object>()));
			BlackBearCubHealth = config("Black Bear Cub", "Health", 60, new ConfigDescription("Declare health points for Black Bear Cub", (AcceptableValueBase)null, Array.Empty<object>()));
			PolarBearCubHealth = config("Polar Bear Cub", "Health", 60, new ConfigDescription("Declare health points for Polar Bear Cub", (AcceptableValueBase)null, Array.Empty<object>()));
			BearCubGrowupTime = config("Bear Cub", "Grow-up time", 1200, new ConfigDescription("Declare growup time needed to convert cub into a Bear. Time in seconds.", (AcceptableValueBase)null, Array.Empty<object>()));
			BlackBearCubGrowupTime = config("Black Bear Cub", "Grow-up time", 1200, new ConfigDescription("Declare growup time needed to convert cub into a Black Bear. Time in seconds.", (AcceptableValueBase)null, Array.Empty<object>()));
			PolarBearCubGrowupTime = config("Polar Bear Cub", "Grow-up time", 1200, new ConfigDescription("Declare growup time needed to convert cub into a Polar Bear. Time in seconds.", (AcceptableValueBase)null, Array.Empty<object>()));
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "sfx_odinbear_footstep");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "sfx_odinbear_alerted");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "sfx_odinbear_death");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "vfx_odinbear_death");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "sfx_odinbear_idle");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "sfx_odinbear_hit");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "fx_odinbear_crit");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "fx_odinbear_backstab");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "vfx_odinbear_hit");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "vfx_odinbear_soothed");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "vfx_odinbear_love");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "sfx_odinbear_consume");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "sfx_odinbear_attack_hit");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "MidgardBear_cub_Rag");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "MidgardBear_cub_Rag_White");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "MidgardBear_cub_Rag_Black");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "MidgardBear_Rag");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "MidgardBear_Rag_White");
			ItemManager.PrefabManager.RegisterPrefab("odinbear", "MidgardBear_Rag_Black");
			new Item("odinbear", "OdinBear_Attack_Bite").Configurable = Configurability.Stats;
			new Item("odinbear", "OdinBear_Attack_ClawL").Configurable = Configurability.Stats;
			new Item("odinbear", "OdinBear_Attack_ClawR").Configurable = Configurability.Stats;
			new Item("odinbear", "OdinBear_Attack_Bite_Polar").Configurable = Configurability.Stats;
			new Item("odinbear", "OdinBear_Attack_ClawL_White").Configurable = Configurability.Stats;
			new Item("odinbear", "OdinBear_Attack_ClawR_White").Configurable = Configurability.Stats;
			new Item("odinbear", "OdinBear_Attack_Bite_Black").Configurable = Configurability.Stats;
			new Item("odinbear", "OdinBear_Attack_ClawL_Black").Configurable = Configurability.Stats;
			new Item("odinbear", "OdinBear_Attack_ClawR_Black").Configurable = Configurability.Stats;
			Item item = new Item("odinbear", "SaddleMidgardBear");
			item.Crafting.Add(CraftingTable.Workbench, 1);
			item.RequiredItems.Add("LeatherScraps", 10);
			item.RequiredItems.Add("Bronze", 8);
			new Item("odinbear", "OdinBearFur");
			new Item("odinbear", "TrophyMidgardBear");
			new Item("odinbear", "OdinBearMeat_Raw");
			new Item("odinbear", "OdinBearMeat_Cooked");
			Item item2 = new Item("odinbear", "Midgard_BearJerky");
			item2.Crafting.Add(CraftingTable.Cauldron, 3);
			item2.RequiredItems.Add("OdinBearMeat_Raw", 1);
			item2.RequiredItems.Add("Honey", 1);
			item2.Configurable = Configurability.Recipe;
			Item item3 = new Item("odinbear", "Midgard_BearStew");
			item3.Crafting.Add(CraftingTable.Cauldron, 5);
			item3.RequiredItems.Add("OdinBearMeat_Raw", 1);
			item3.RequiredItems.Add("Vineberry", 2);
			item3.RequiredItems.Add("AsksvinMeat", 1);
			item3.Configurable = Configurability.Recipe;
			Item item4 = new Item("odinbear", "MidgardBear_Shield");
			item4.Crafting.Add(CraftingTable.Forge, 1);
			item4.RequiredItems.Add("TrophyMidgardBear", 1);
			item4.RequiredItems.Add("OdinBearFur", 4);
			item4.RequiredItems.Add("Iron", 8);
			item4.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item4.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item4.Configurable = Configurability.Full;
			Item item5 = new Item("odinbear", "CapeMidgardBear");
			item5.Crafting.Add(CraftingTable.Workbench, 1);
			item5.RequiredItems.Add("OdinBearFur", 5);
			item5.RequiredItems.Add("Bronze", 3);
			item5.RequiredItems.Add("Dandelion", 3);
			item5.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item5.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item5.Configurable = Configurability.Full;
			Item item6 = new Item("odinbear", "CapeMidgardBear_Puff");
			item6.Crafting.Add(CraftingTable.Workbench, 1);
			item6.RequiredItems.Add("OdinBearFur", 10);
			item6.RequiredItems.Add("JuteRed", 5);
			item6.RequiredItems.Add("Chain", 4);
			item6.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item6.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item6.Configurable = Configurability.Full;
			Item item7 = new Item("odinbear", "MidgardBear_Helmet_T2");
			item7.Crafting.Add(CraftingTable.Forge, 1);
			item7.RequiredItems.Add("TrophyMidgardBear", 1);
			item7.RequiredItems.Add("OdinBearFur", 10);
			item7.RequiredItems.Add("Iron", 5);
			item7.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item7.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item7.Configurable = Configurability.Full;
			Item item8 = new Item("odinbear", "MidgardBear_Helmet_T3");
			item8.Crafting.Add(CraftingTable.Forge, 3);
			item8.RequiredItems.Add("MidgardBear_Helmet_T2", 1);
			item8.RequiredItems.Add("OdinBearFur", 12);
			item8.RequiredItems.Add("WolfPelt", 5);
			item8.RequiredItems.Add("Silver", 8);
			item8.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item8.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item8.Configurable = Configurability.Full;
			Item item9 = new Item("odinbear", "MidgardBear_Helmet_T4");
			item9.Crafting.Add(CraftingTable.ArtisanTable, 1);
			item9.RequiredItems.Add("MidgardBear_Helmet_T3", 1);
			item9.RequiredItems.Add("LoxPelt", 10);
			item9.RequiredItems.Add("BlackMetal", 8);
			item9.RequiredItems.Add("Flametal", 4);
			item9.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item9.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item9.Configurable = Configurability.Full;
			Item item10 = new Item("odinbear", "ArmorMidgardBearLegs_T1");
			item10.Crafting.Add(CraftingTable.Workbench, 1);
			item10.RequiredItems.Add("OdinBearFur", 6);
			item10.RequiredItems.Add("LeatherScraps", 10);
			item10.RequiredItems.Add("Bronze", 3);
			item10.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item10.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item10.Configurable = Configurability.Full;
			Item item11 = new Item("odinbear", "ArmorMidgardBearLegs_T2");
			item11.Crafting.Add(CraftingTable.Forge, 1);
			item11.RequiredItems.Add("ArmorMidgardBearLegs_T1", 1);
			item11.RequiredItems.Add("OdinBearFur", 4);
			item11.RequiredItems.Add("Bronze", 8);
			item11.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item11.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item11.Configurable = Configurability.Full;
			Item item12 = new Item("odinbear", "ArmorMidgardBearLegs_T3");
			item12.Crafting.Add(CraftingTable.Forge, 3);
			item12.RequiredItems.Add("ArmorMidgardBearLegs_T2", 1);
			item12.RequiredItems.Add("OdinBearFur", 8);
			item12.RequiredItems.Add("Iron", 10);
			item12.RequiredItems.Add("BoneFragments", 10);
			item12.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item12.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item12.Configurable = Configurability.Full;
			Item item13 = new Item("odinbear", "ArmorMidgardBearLegs_T4");
			item13.Crafting.Add(CraftingTable.ArtisanTable, 1);
			item13.RequiredItems.Add("ArmorMidgardBearLegs_T3", 1);
			item13.RequiredItems.Add("OdinBearFur", 15);
			item13.RequiredItems.Add("BlackMetal", 10);
			item13.RequiredItems.Add("Flametal", 5);
			item13.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item13.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item13.Configurable = Configurability.Full;
			Item item14 = new Item("odinbear", "ArmorMidgardBearChest_T1");
			item14.Crafting.Add(CraftingTable.Workbench, 1);
			item14.RequiredItems.Add("TrophyMidgardBear", 1);
			item14.RequiredItems.Add("OdinBearFur", 6);
			item14.RequiredItems.Add("LeatherScraps", 10);
			item14.RequiredItems.Add("Bronze", 6);
			item14.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item14.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item14.Configurable = Configurability.Full;
			Item item15 = new Item("odinbear", "ArmorMidgardBearChest_T2");
			item15.Crafting.Add(CraftingTable.Forge, 1);
			item15.RequiredItems.Add("ArmorMidgardBearChest_T1", 1);
			item15.RequiredItems.Add("TrophyMidgardBear", 1);
			item15.RequiredItems.Add("OdinBearFur", 10);
			item15.RequiredItems.Add("Iron", 8);
			item15.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item15.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item15.Configurable = Configurability.Full;
			Item item16 = new Item("odinbear", "ArmorMidgardBearChest_T3");
			item16.Crafting.Add(CraftingTable.Forge, 3);
			item16.RequiredItems.Add("ArmorMidgardBearChest_T2", 1);
			item16.RequiredItems.Add("TrophyMidgardBear", 2);
			item16.RequiredItems.Add("OdinBearFur", 15);
			item16.RequiredItems.Add("Silver", 12);
			item16.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item16.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item16.Configurable = Configurability.Full;
			Item item17 = new Item("odinbear", "ArmorMidgardBearChest_T4");
			item17.Crafting.Add(CraftingTable.ArtisanTable, 1);
			item17.RequiredItems.Add("ArmorMidgardBearChest_T3", 1);
			item17.RequiredItems.Add("TrophyMidgardBear", 2);
			item17.RequiredItems.Add("OdinBearFur", 15);
			item17.RequiredItems.Add("Flametal", 8);
			item17.RequiredUpgradeItems.Add("TrophyMidgardBear", 1);
			item17.RequiredUpgradeItems.Add("OdinBearFur", 5);
			item17.Configurable = Configurability.Full;
			raeBear = new Creature("odinbear", "MidgardBear")
			{
				ConfigurationEnabled = true,
				CreatureFaction = (Faction)2,
				Biome = (Biome)12,
				CanSpawn = true,
				CanBeTamed = true,
				CanHaveStars = true,
				TamingTime = 1000f,
				FedDuration = 600f,
				FoodItems = "Honey",
				SpawnChance = 3f,
				GroupSize = new CreatureManager.Range(1f, 1f),
				CheckSpawnInterval = 2000,
				SpecificSpawnTime = SpawnTime.Always,
				SpecificSpawnArea = SpawnArea.Everywhere,
				RequiredWeather = Weather.None,
				RequiredAltitude = new CreatureManager.Range(10f, 1000f),
				AttackImmediately = false,
				ForestSpawn = Forest.Both,
				SpawnAltitude = 0.1f,
				Maximum = 1
			};
			raeBear.Drops["OdinBearFur"].Amount = new CreatureManager.Range(1f, 5f);
			raeBear.Drops["OdinBearFur"].DropChance = 66f;
			raeBear.Drops["OdinBearMeat_Raw"].Amount = new CreatureManager.Range(3f, 6f);
			raeBear.Drops["OdinBearMeat_Raw"].DropChance = 66f;
			raeBear.Drops["TrophyMidgardBear"].Amount = new CreatureManager.Range(1f, 1f);
			raeBear.Drops["TrophyMidgardBear"].DropChance = 20f;
			((Character)raeBear.Prefab.GetComponent<Humanoid>()).m_runSpeed = BearRunningSpeed.Value;
			((Character)raeBear.Prefab.GetComponent<Humanoid>()).m_health = BearHealth.Value;
			raeBear.Prefab.GetComponentInChildren<Sadle>(true).m_maxStamina = BearStamina.Value;
			raeBear.Prefab.GetComponentInChildren<Sadle>(true).m_staminaRegen = BearStaminaRegen.Value;
			raeBear.Prefab.GetComponentInChildren<Sadle>(true).m_staminaRegenHungry = BearStaminaRegenHungry.Value;
			raeBearPolar = new Creature("odinbear", "MidgardBear_Polar")
			{
				ConfigurationEnabled = true,
				CreatureFaction = (Faction)8,
				Biome = (Biome)4,
				CanSpawn = true,
				CanBeTamed = true,
				CanHaveStars = true,
				TamingTime = 1000f,
				FedDuration = 600f,
				FoodItems = "Honey",
				SpawnChance = 3f,
				GroupSize = new CreatureManager.Range(1f, 1f),
				CheckSpawnInterval = 2000,
				SpecificSpawnTime = SpawnTime.Always,
				SpecificSpawnArea = SpawnArea.Everywhere,
				RequiredWeather = Weather.None,
				RequiredAltitude = new CreatureManager.Range(10f, 1000f),
				AttackImmediately = false,
				ForestSpawn = Forest.Both,
				SpawnAltitude = 0.1f,
				Maximum = 1
			};
			raeBearPolar.Drops["OdinBearFur"].Amount = new CreatureManager.Range(1f, 5f);
			raeBearPolar.Drops["OdinBearFur"].DropChance = 66f;
			raeBearPolar.Drops["OdinBearMeat_Raw"].Amount = new CreatureManager.Range(3f, 6f);
			raeBearPolar.Drops["OdinBearMeat_Raw"].DropChance = 66f;
			raeBearPolar.Drops["TrophyMidgardBear"].Amount = new CreatureManager.Range(1f, 1f);
			raeBearPolar.Drops["TrophyMidgardBear"].DropChance = 20f;
			((Character)raeBearPolar.Prefab.GetComponent<Humanoid>()).m_runSpeed = PolarBearRunningSpeed.Value;
			((Character)raeBearPolar.Prefab.GetComponent<Humanoid>()).m_health = PolarBearHealth.Value;
			raeBearPolar.Prefab.GetComponentInChildren<Sadle>(true).m_maxStamina = PolarBearStamina.Value;
			raeBearPolar.Prefab.GetComponentInChildren<Sadle>(true).m_staminaRegen = PolarBearStaminaRegen.Value;
			raeBearPolar.Prefab.GetComponentInChildren<Sadle>(true).m_staminaRegenHungry = PolarBearStaminaRegenHungry.Value;
			raeBearBlack = new Creature("odinbear", "MidgardBear_Black")
			{
				ConfigurationEnabled = true,
				CreatureFaction = (Faction)2,
				Biome = (Biome)1,
				CanSpawn = true,
				CanBeTamed = true,
				CanHaveStars = true,
				TamingTime = 1000f,
				FedDuration = 600f,
				FoodItems = "Honey",
				SpawnChance = 3f,
				GroupSize = new CreatureManager.Range(1f, 1f),
				CheckSpawnInterval = 2000,
				SpecificSpawnTime = SpawnTime.Always,
				SpecificSpawnArea = SpawnArea.Everywhere,
				RequiredWeather = Weather.None,
				RequiredAltitude = new CreatureManager.Range(10f, 1000f),
				AttackImmediately = false,
				ForestSpawn = Forest.Both,
				SpawnAltitude = 0.1f,
				Maximum = 1
			};
			raeBearBlack.Drops["OdinBearFur"].Amount = new CreatureManager.Range(1f, 2f);
			raeBearBlack.Drops["OdinBearFur"].DropChance = 66f;
			raeBearBlack.Drops["OdinBearMeat_Raw"].Amount = new CreatureManager.Range(1f, 2f);
			raeBearBlack.Drops["OdinBearMeat_Raw"].DropChance = 66f;
			raeBearBlack.Drops["TrophyMidgardBear"].Amount = new CreatureManager.Range(1f, 1f);
			raeBearBlack.Drops["TrophyMidgardBear"].DropChance = 20f;
			((Character)raeBearBlack.Prefab.GetComponent<Humanoid>()).m_runSpeed = BlackBearRunningSpeed.Value;
			((Character)raeBearBlack.Prefab.GetComponent<Humanoid>()).m_health = BlackBearHealth.Value;
			raeBearBlack.Prefab.GetComponentInChildren<Sadle>(true).m_maxStamina = BlackBearStamina.Value;
			raeBearBlack.Prefab.GetComponentInChildren<Sadle>(true).m_staminaRegen = BlackBearStaminaRegen.Value;
			raeBearBlack.Prefab.GetComponentInChildren<Sadle>(true).m_staminaRegenHungry = BlackBearStaminaRegenHungry.Value;
			Creature creature = new Creature("odinbear", "MidgardBear_cub");
			creature.Biome = (Biome)0;
			creature.CanSpawn = true;
			creature.SpawnChance = 100f;
			creature.GroupSize = new CreatureManager.Range(1f, 1f);
			creature.Maximum = 1;
			creature.Drops["OdinBearMeat_Raw"].Amount = new CreatureManager.Range(1f, 1f);
			creature.Drops["OdinBearMeat_Raw"].DropChance = 50f;
			creature.Drops["OdinBearFur"].Amount = new CreatureManager.Range(1f, 1f);
			creature.Drops["OdinBearFur"].DropChance = 50f;
			((Character)creature.Prefab.GetComponent<Humanoid>()).m_health = BearCubHealth.Value;
			creature.Prefab.GetComponent<Growup>().m_growTime = BearCubGrowupTime.Value;
			Creature creature2 = new Creature("odinbear", "MidgardBear_black_cub");
			creature2.Biome = (Biome)0;
			creature2.CanSpawn = true;
			creature2.SpawnChance = 100f;
			creature2.GroupSize = new CreatureManager.Range(1f, 1f);
			creature2.Maximum = 1;
			creature2.Drops["OdinBearMeat_Raw"].Amount = new CreatureManager.Range(1f, 1f);
			creature2.Drops["OdinBearMeat_Raw"].DropChance = 50f;
			creature2.Drops["OdinBearFur"].Amount = new CreatureManager.Range(1f, 1f);
			creature2.Drops["OdinBearFur"].DropChance = 50f;
			((Character)creature2.Prefab.GetComponent<Humanoid>()).m_health = BlackBearCubHealth.Value;
			creature2.Prefab.GetComponent<Growup>().m_growTime = BlackBearCubGrowupTime.Value;
			Creature creature3 = new Creature("odinbear", "MidgardBear_polar_cub");
			creature3.Biome = (Biome)0;
			creature3.CanSpawn = true;
			creature3.SpawnChance = 100f;
			creature3.GroupSize = new CreatureManager.Range(1f, 1f);
			creature3.Maximum = 1;
			creature3.Drops["OdinBearMeat_Raw"].Amount = new CreatureManager.Range(1f, 1f);
			creature3.Drops["OdinBearMeat_Raw"].DropChance = 50f;
			creature3.Drops["OdinBearFur"].Amount = new CreatureManager.Range(1f, 1f);
			creature3.Drops["OdinBearFur"].DropChance = 50f;
			((Character)creature3.Prefab.GetComponent<Humanoid>()).m_health = PolarBearCubHealth.Value;
			creature3.Prefab.GetComponent<Growup>().m_growTime = PolarBearCubGrowupTime.Value;
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			new Harmony("Raelaziel.OdinBear").PatchAll(executingAssembly);
		}

		private void Start()
		{
			ApplyBearStats();
		}

		private void ApplyBearStats()
		{
			if ((Object)(object)raeBear?.Prefab != (Object)null)
			{
				Humanoid component = raeBear.Prefab.GetComponent<Humanoid>();
				((Character)component).m_runSpeed = BearRunningSpeed.Value;
				((Character)component).m_health = BearHealth.Value;
				Sadle componentInChildren = raeBear.Prefab.GetComponentInChildren<Sadle>(true);
				componentInChildren.m_maxStamina = BearStamina.Value;
				componentInChildren.m_staminaRegen = BearStaminaRegen.Value;
				componentInChildren.m_staminaRegenHungry = BearStaminaRegenHungry.Value;
			}
			if ((Object)(object)raeBearPolar?.Prefab != (Object)null)
			{
				Humanoid component2 = raeBearPolar.Prefab.GetComponent<Humanoid>();
				((Character)component2).m_runSpeed = PolarBearRunningSpeed.Value;
				((Character)component2).m_health = PolarBearHealth.Value;
				Sadle componentInChildren2 = raeBearPolar.Prefab.GetComponentInChildren<Sadle>(true);
				componentInChildren2.m_maxStamina = PolarBearStamina.Value;
				componentInChildren2.m_staminaRegen = PolarBearStaminaRegen.Value;
				componentInChildren2.m_staminaRegenHungry = PolarBearStaminaRegenHungry.Value;
			}
			if ((Object)(object)raeBearBlack?.Prefab != (Object)null)
			{
				Humanoid component3 = raeBearBlack.Prefab.GetComponent<Humanoid>();
				((Character)component3).m_runSpeed = BlackBearRunningSpeed.Value;
				((Character)component3).m_health = BlackBearHealth.Value;
				Sadle componentInChildren3 = raeBearBlack.Prefab.GetComponentInChildren<Sadle>(true);
				componentInChildren3.m_maxStamina = BlackBearStamina.Value;
				componentInChildren3.m_staminaRegen = BlackBearStaminaRegen.Value;
				componentInChildren3.m_staminaRegenHungry = BlackBearStaminaRegenHungry.Value;
			}
		}
	}
}
namespace CreatureManager
{
	public enum Toggle
	{
		On,
		Off
	}
	[PublicAPI]
	public enum GlobalKey
	{
		[InternalName("")]
		None,
		[InternalName("defeated_bonemass")]
		KilledBonemass,
		[InternalName("defeated_gdking")]
		KilledElder,
		[InternalName("defeated_goblinking")]
		KilledYagluth,
		[InternalName("defeated_dragon")]
		KilledModer,
		[InternalName("defeated_eikthyr")]
		KilledEikthyr,
		[InternalName("KilledTroll")]
		KilledTroll,
		[InternalName("killed_surtling")]
		KilledSurtling
	}
	[PublicAPI]
	[Flags]
	public enum Weather
	{
		[InternalName("")]
		None = 0,
		[InternalName("Clear")]
		ClearSkies = 1,
		[InternalName("Heath clear")]
		MeadowsClearSkies = 4,
		[InternalName("LightRain")]
		LightRain = 8,
		[InternalName("Rain")]
		Rain = 0x10,
		[InternalName("ThunderStorm")]
		ThunderStorm = 0x20,
		[InternalName("nofogts")]
		ClearThunderStorm = 0x40,
		[InternalName("SwampRain")]
		SwampRain = 0x80,
		[InternalName("Darklands_dark")]
		MistlandsDark = 0x100,
		[InternalName("Ashrain")]
		AshlandsAshrain = 0x200,
		[InternalName("Snow")]
		MountainSnow = 0x400,
		[InternalName("SnowStorm")]
		MountainBlizzard = 0x800,
		[InternalName("DeepForest Mist")]
		BlackForestFog = 0x1000,
		[InternalName("Misty")]
		Fog = 0x2000,
		[InternalName("Twilight_Snow")]
		DeepNorthSnow = 0x4000,
		[InternalName("Twilight_SnowStorm")]
		DeepNorthSnowStorm = 0x8000,
		[InternalName("Twilight_Clear")]
		DeepNorthClear = 0x10000,
		[InternalName("Eikthyr")]
		EikthyrsThunderstorm = 0x20000,
		[InternalName("GDKing")]
		EldersHaze = 0x40000,
		[InternalName("Bonemass")]
		BonemassDownpour = 0x80000,
		[InternalName("Moder")]
		ModersVortex = 0x100000,
		[InternalName("GoblinKing")]
		YagluthsMagicBlizzard = 0x200000,
		[InternalName("Crypt")]
		Crypt = 0x400000,
		[InternalName("SunkenCrypt")]
		SunkenCrypt = 0x800000
	}
	[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(1)]
	[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
	public class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	public enum DropOption
	{
		Disabled,
		Default,
		Custom
	}
	public enum SpawnOption
	{
		Disabled,
		Default,
		Custom
	}
	public enum SpawnTime
	{
		Day,
		Night,
		Always
	}
	public enum SpawnArea
	{
		Center,
		Edge,
		Everywhere
	}
	public enum Forest
	{
		Yes,
		No,
		Both
	}
	[PublicAPI]
	public struct Range
	{
		public float min;

		public float max;

		public Range(float min, float max)
		{
			this.min = min;
			this.max = max;
		}
	}
	[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(1)]
	[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
	[PublicAPI]
	public class Creature
	{
		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
		[PublicAPI]
		public class DropList
		{
			[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
			internal class SerializedDrops
			{
				[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0, 1, 1 })]
				public readonly List<KeyValuePair<string, Drop>> Drops;

				public SerializedDrops(DropList drops, Creature creature)
				{
					Drops = (drops.drops ?? creature.Prefab.GetComponent<CharacterDrop>()?.m_drops.ToDictionary([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (Drop drop) => ((Object)drop.m_prefab).name, [<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (Drop drop) => new Drop
					{
						Amount = new Range(drop.m_amountMin, drop.m_amountMax),
						DropChance = drop.m_chance,
						DropOnePerPlayer = drop.m_onePerPlayer,
						MultiplyDropByLevel = drop.m_levelMultiplier
					}) ?? new Dictionary<string, Drop>()).ToList();
				}

				public SerializedDrops([<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0, 1, 1 })] List<KeyValuePair<string, Drop>> drops)
				{
					Drops = drops;
				}

				public SerializedDrops(string reqs)
				{
					Drops = (from r in reqs.Split(new char[1] { ',' })
						select r.Split(new char[1] { ':' })).ToDictionary([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (string[] l) => l[0], [<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (string[] parts) =>
					{
						Range amount = new Range(1f, 1f);
						if (parts.Length > 1)
						{
							string[] array = parts[1].Split(new char[1] { '-' });
							if (!int.TryParse(array[0], out var result))
							{
								result = 1;
							}
							if (array.Length == 1 || !int.TryParse(array[0], out var result2))
							{
								result2 = result;
							}
							amount = new Range(result, result2);
						}
						float result3;
						return new Drop
						{
							Amount = amount,
							DropChance = ((parts.Length > 2 && float.TryParse(parts[2], out result3)) ? result3 : 100f),
							DropOnePerPlayer = (parts.Length > 3 && parts[3] == "onePerPlayer"),
							MultiplyDropByLevel = (parts.Length > 4 && parts[4] == "multiplyByLevel")
						};
					}).ToList();
				}

				public override string ToString()
				{
					return string.Join(",", Drops.Select([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (KeyValuePair<string, Drop> kv) => string.Format("{0}:{1}-{2}:{3}:{4}:{5}", kv.Key, kv.Value.Amount.min, kv.Value.Amount.max, kv.Value.DropChance, kv.Value.DropOnePerPlayer ? "onePerPlayer" : "unrestricted", kv.Value.MultiplyDropByLevel ? "multiplyByLevel" : "unaffectedByLevel")));
				}
			}

			[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 2, 1, 1 })]
			private Dictionary<string, Drop> drops;

			public Drop this[string prefabName]
			{
				get
				{
					if (!(drops ?? (drops = new Dictionary<string, Drop>())).TryGetValue(prefabName, out var value))
					{
						return drops[prefabName] = new Drop();
					}
					return value;
				}
			}

			public void None()
			{
				drops = new Dictionary<string, Drop>();
			}

			[HarmonyPriority(700)]
			internal static void AddDropsToCreature()
			{
				foreach (Creature registeredCreature in registeredCreatures)
				{
					UpdateDrops(registeredCreature);
				}
			}

			internal static void UpdateDrops(Creature creature)
			{
				if (creatureConfigs[creature].Drops.get() == DropOption.Default && creature.Drops.drops == null)
				{
					return;
				}
				CharacterDrop val = creature.Prefab.GetComponent<CharacterDrop>() ?? creature.Prefab.AddComponent<CharacterDrop>();
				val.m_drops = (from d in (creatureConfigs[creature].Drops.get() switch
					{
						DropOption.Custom => new SerializedDrops(creatureConfigs[creature].CustomDrops.get()).Drops, 
						DropOption.Disabled => new List<KeyValuePair<string, Drop>>(), 
						_ => creature.Drops.drops.ToList(), 
					}).Select((Func<KeyValuePair<string, Drop>, Drop>)([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (KeyValuePair<string, Drop> kv) =>
					{
						//IL_005e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0063: Unknown result type (might be due to invalid IL or missing references)
						//IL_006a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0082: Unknown result type (might be due to invalid IL or missing references)
						//IL_009a: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
						//IL_00d7: Expected O, but got Unknown
						if (kv.Key == "" || ZNetScene.instance == null)
						{
							return null;
						}
						GameObject prefab = ZNetScene.instance.GetPrefab(kv.Key);
						if (prefab != null)
						{
							return new Drop
							{
								m_prefab = prefab,
								m_amountMin = (int)kv.Value.Amount.min,
								m_amountMax = (int)kv.Value.Amount.max,
								m_chance = kv.Value.DropChance / 100f,
								m_onePerPlayer = kv.Value.DropOnePerPlayer,
								m_levelMultiplier = kv.Value.MultiplyDropByLevel
							};
						}
						Debug.LogWarning((object)("Found invalid prefab name " + kv.Key + " for creature " + ((Object)creature.Prefab).name));
						return null;
					}))
					where d != null
					select d).ToList();
			}
		}

		[PublicAPI]
		[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)]
		public class Drop
		{
			public Range Amount = new Range(1f, 1f);

			public float DropChance = 100f;

			public bool DropOnePerPlayer;

			public bool MultiplyDropByLevel = true;
		}

		[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)]
		private class CustomConfig<[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)] T>
		{
			[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(1)]
			public Func<T> get;

			[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 2, 1 })]
			public ConfigEntry<T> config;
		}

		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
		private class CreatureConfig
		{
			public readonly CustomConfig<SpawnOption> Spawn = new CustomConfig<SpawnOption>();

			public readonly CustomConfig<Toggle> CanBeTamed = new CustomConfig<Toggle>();

			public readonly CustomConfig<string> ConsumesItemName = new CustomConfig<string>();

			public readonly CustomConfig<float> FedDuration = new CustomConfig<float>();

			public readonly CustomConfig<float> TamingTime = new CustomConfig<float>();

			public readonly CustomConfig<Toggle> SpawnsTamed = new CustomConfig<Toggle>();

			public readonly CustomConfig<Faction> CreatureFaction = new CustomConfig<Faction>();

			public readonly CustomConfig<SpawnTime> SpecificSpawnTime = new CustomConfig<SpawnTime>();

			public readonly CustomConfig<Range> RequiredAltitude = new CustomConfig<Range>();

			public readonly CustomConfig<Range> RequiredOceanDepth = new CustomConfig<Range>();

			public readonly CustomConfig<GlobalKey> RequiredGlobalKey = new CustomConfig<GlobalKey>();

			public readonly CustomConfig<Range> GroupSize = new CustomConfig<Range>();

			public readonly CustomConfig<Biome> Biome = new CustomConfig<Biome>();

			public readonly CustomConfig<SpawnArea> SpecificSpawnArea = new CustomConfig<SpawnArea>();

			public readonly CustomConfig<Weather> RequiredWeather = new CustomConfig<Weather>();

			public readonly CustomConfig<float> SpawnAltitude = new CustomConfig<float>();

			public readonly CustomConfig<Toggle> CanHaveStars = new CustomConfig<Toggle>();

			public readonly CustomConfig<Toggle> AttackImmediately = new CustomConfig<Toggle>();

			public readonly CustomConfig<int> CheckSpawnInterval = new CustomConfig<int>();

			public readonly CustomConfig<float> SpawnChance = new CustomConfig<float>();

			public readonly CustomConfig<Forest> ForestSpawn = new CustomConfig<Forest>();

			public readonly CustomConfig<int> Maximum = new CustomConfig<int>();

			public readonly CustomConfig<DropOption> Drops = new CustomConfig<DropOption>();

			public readonly CustomConfig<string> CustomDrops = new CustomConfig<string>();
		}

		[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)]
			public string Category;

			[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 2, 1 })]
			[UsedImplicitly]
			public Action<ConfigEntryBase> CustomDrawer;
		}

		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
		private class AcceptableEnumValues<[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)] T> : AcceptableValueBase where T : struct, IConvertible
		{
			[PublicAPI]
			[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0 })]
			public virtual T[] AcceptableValues
			{
				[return: <3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0 })]
				get;
			}

			public AcceptableEnumValues([<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0 })] params T[] acceptableValues)
				: base(typeof(T))
			{
				AcceptableValues = acceptableValues;
			}

			public override object Clamp(object value)
			{
				if (!((AcceptableValueBase)this).IsValid(value))
				{
					return AcceptableValues[0];
				}
				return value;
			}

			public override bool IsValid(object value)
			{
				return AcceptableValues.Contains((T)value);
			}

			public override string ToDescriptionString()
			{
				return string.Join(", ", AcceptableValues);
			}
		}

		public bool ConfigurationEnabled = true;

		public readonly GameObject Prefab;

		public DropList Drops = new DropList();

		public bool CanSpawn = true;

		public bool CanBeTamed;

		[Description("List of items the creature consumes to get tame.\nFor multiple item names, separate them with a comma.")]
		public string FoodItems;

		[Description("How long the creature remains fed after eating.")]
		public float FedDuration;

		[Description("Time it takes to tame the creature.")]
		public float TamingTime;

		[Description("If the creature spawns tamed.")]
		public bool SpawnsTamed;

		[Description("The creature faction the creature belongs to.")]
		public Faction CreatureFaction;

		[Description("Sets the time of day the creature can spawn.")]
		public SpawnTime SpecificSpawnTime = SpawnTime.Always;

		[Description("Sets the minimum and maximum altitude for the creature to spawn.")]
		public Range RequiredAltitude = new Range(5f, 1000f);

		[Description("Sets the minimum and maximum depth of the ocean for the creature to spawn.")]
		public Range RequiredOceanDepth = new Range(0f, 0f);

		[Description("Sets a global key required for the creature to spawn.")]
		public GlobalKey RequiredGlobalKey;

		[Description("Sets a range for the group size the creature spawns in.")]
		public Range GroupSize = new Range(1f, 1f);

		[Description("Sets the biome the creature spawns in.")]
		public Biome Biome = (Biome)1;

		[Description("Sets spawning area for the creature inside the biome.\nUse SpawnArea.Edge, to make the creature spawn more towards the edge of the biome.\nUse SpawnArea.Center, to make the creature spawn more towards the center of the biome.")]
		public SpawnArea SpecificSpawnArea = SpawnArea.Everywhere;

		[Description("Sets the weather condition for the creature to spawn.\nUse the Weather enum for easy configuration.")]
		public Weather RequiredWeather;

		[Description("Sets altitude relative to the current ground level for the creature to spawn.\nShould be a higher number for flying creatures, so they spawn in the sky.")]
		public float SpawnAltitude = 0.5f;

		public bool CanHaveStars = true;

		[Description("Controls the first AI command right after spawn.\nSet to true for the creature to immediately start to hunt down the player.")]
		public bool AttackImmediately;

		[Description("The time between attempts to spawn the creature in.")]
		public int CheckSpawnInterval = 600;

		[Description("The chance in percent for the creature to spawn, every time Valheim checks if it should spawn.")]
		public float SpawnChance = 100f;

		[Description("Can be used to make the creature spawn in forests or prevent it from spawning in forests.\nUse the Forest enum for easy configuration.")]
		public Forest ForestSpawn = Forest.Both;

		[Description("Sets the maximum number of the creature that can be near the player, before Valheim disables its spawn.")]
		public int Maximum = 1;

		private static readonly List<Creature> registeredCreatures = new List<Creature>();

		private static Dictionary<Creature, CreatureConfig> creatureConfigs = new Dictionary<Creature, CreatureConfig>();

		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)]
		private static object configManager;

		private static List<SpawnData> lastRegisteredSpawns = new List<SpawnData>();

		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)]
		private static Localization _english;

		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static bool hasConfigSync = true;

		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)]
		private static object _configSync;

		private static Localization english => _english ?? (_english = LocalizationCache.ForLanguage("English"));

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

		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)]
		private static object configSync
		{
			[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(2)]
			get
			{
				if (_configSync == null && hasConfigSync)
				{
					Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
					if ((object)type != null)
					{
						_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " CreatureManager");
						type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
						type.GetProperty("IsLocked").SetValue(_configSync, true);
					}
					else
					{
						hasConfigSync = false;
					}
				}
				return _configSync;
			}
		}

		public Creature(string assetBundleFileName, string prefabName, string folderName = "assets")
			: this(PrefabManager.RegisterAssetBundle(assetBundleFileName, folderName), prefabName)
		{
		}

		public Creature(AssetBundle bundle, string prefabName)
			: this(PrefabManager.RegisterPrefab(bundle, prefabName))
		{
		}

		public Creature(GameObject creature)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Prefab = creature;
			registeredCreatures.Add(this);
			CanBeTamed = Object.op_Implicit((Object)(object)creature.GetComponent<Tameable>());
			FoodItems = string.Join(",", (from i in creature.GetComponent<MonsterAI>()?.m_consumeItems
				where Object.op_Implicit((Object)(object)i.m_itemData.m_dropPrefab)
				select ((Object)i.m_itemData.m_dropPrefab).name) ?? Enumerable.Empty<string>());
		}

		public LocalizeKey Localize()
		{
			return new LocalizeKey(Prefab.GetComponent<Character>().m_name);
		}

		internal static void Patch_FejdStartup()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Expected O, but got Unknown
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Expected O, but got Unknown
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Expected O, but got Unknown
			//IL_078a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0794: Expected O, but got Unknown
			Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			configManager = ((type == null) ? null : Chainloader.ManagerObject.GetComponent(type));
			if (!TomlTypeConverter.CanConvert(typeof(Range)))
			{
				TomlTypeConverter.AddConverter(typeof(Range), new TypeConverter
				{
					ConvertToObject = [<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (string s, Type _) =>
					{
						Match match = Regex.Match(s, "^(-?\\d+(?:\\.\\d*)?)\\s*-\\s*(-?\\d+(?:\\.\\d*)?)$");
						return match.Success ? new Range(float.Parse(match.Groups[1].Value), float.Parse(match.Groups[2].Value)) : default(Range);
					},
					ConvertToString = [<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (object obj, Type _) =>
					{
						Range range = (Range)obj;
						return $"{range.min} - {range.max}";
					}
				});
			}
			bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
			plugin.Config.SaveOnConfigSet = false;
			foreach (Creature registeredCreature in registeredCreatures)
			{
				Creature creature = registeredCreature;
				CreatureConfig creatureConfig2 = (creatureConfigs[creature] = new CreatureConfig());
				CreatureConfig cfg = creatureConfig2;
				string name2 = creature.Prefab.GetComponent<Character>().m_name;
				string englishName = new Regex("['[\"\\]]").Replace(english.Localize(name2), "").Trim();
				string localizedName = Localization.instance.Localize(name2).Trim();
				int order = 0;
				ConfigurationManagerAttributes tameConfigVisibility = new ConfigurationManagerAttributes();
				config<Toggle>(cfg.CanBeTamed, () => (!creature.CanBeTamed) ? Toggle.Off : Toggle.On, delegate
				{
					tameConfigVisibility.Browsable = cfg.CanBeTamed.get() == Toggle.On;
					reloadConfigDisplay();
					updateAI();
				}, "Can be tamed", "Decides, if the creature can be tamed.");
				tameConfigVisibility.Browsable = cfg.CanBeTamed.get() == Toggle.On;
				configWithDesc<string>(cfg.ConsumesItemName, [<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] () => creature.FoodItems, updateAI, "Food items", new ConfigDescription("The items the creature consumes to get tame.", (AcceptableValueBase)null, new object[1] { tameConfigVisibility }));
				configWithDesc<float>(cfg.FedDuration, () => creature.FedDuration, updateAI, "Fed Duration", new ConfigDescription("How long the creature stays fed after eating, in seconds.", (AcceptableValueBase)null, new object[1] { tameConfigVisibility }));
				configWithDesc<float>(cfg.TamingTime, () => creature.TamingTime, updateAI, "Time to Tame", new ConfigDescription("The time it takes to tame the creature.", (AcceptableValueBase)null, new object[1] { tameConfigVisibility }));
				configWithDesc<Toggle>(cfg.SpawnsTamed, () => (!creature.SpawnsTamed) ? Toggle.Off : Toggle.On, updateAI, "Spawns Tamed", new ConfigDescription("If on, the creature spawns tamed.", (AcceptableValueBase)null, new object[1] { tameConfigVisibility }));
				ConfigurationManagerAttributes spawnConfigVisibility = new ConfigurationManagerAttributes();
				ConfigurationManagerAttributes dropConfigVisibility = new ConfigurationManagerAttributes();
				config<SpawnOption>(cfg.Spawn, () => creature.CanSpawn ? SpawnOption.Default : SpawnOption.Disabled, delegate
				{
					spawnConfigVisibility.Browsable = cfg.Spawn.get() == SpawnOption.Custom;
					reloadConfigDisplay();
					updateAllSpawnConfigs();
				}, "Spawn", "Configures the spawn for the creature.");
				spawnConfigVisibility.Browsable = cfg.Spawn.get() == SpawnOption.Custom;
				spawnConfig<SpawnTime>(cfg.SpecificSpawnTime, () => creature.SpecificSpawnTime, "Spawn time", "Configures the time of day for the creature to spawn.");
				spawnConfig<Range>(cfg.RequiredAltitude, () => creature.RequiredAltitude, "Required altitude", "Configures the altitude required for the creature to spawn.");
				spawnConfig<Range>(cfg.RequiredOceanDepth, () => creature.RequiredOceanDepth, "Required ocean depth", "Configures the ocean depth required for the creature to spawn.");
				spawnConfig<GlobalKey>(cfg.RequiredGlobalKey, () => creature.RequiredGlobalKey, "Required global key", "Configures the global key required for the creature to spawn.");
				spawnConfig<Range>(cfg.GroupSize, () => creature.GroupSize, "Group size", "Configures the size of the groups in which the creature spawns.");
				spawnConfig<Biome>(cfg.Biome, () => creature.Biome, "Biome", "Configures the biome required for the creature to spawn.");
				spawnConfig<SpawnArea>(cfg.SpecificSpawnArea, () => creature.SpecificSpawnArea, "Spawn area", "Configures if the creature spawns more towards the center or the edge of the biome.");
				spawnConfig<Weather>(cfg.RequiredWeather, () => creature.RequiredWeather, "Required weather", "Configures the weather required for the creature to spawn.");
				spawnConfig<float>(cfg.SpawnAltitude, () => creature.SpawnAltitude, "Spawn altitude", "Configures the height from the ground in which the creature will spawn.");
				spawnConfig<Toggle>(cfg.CanHaveStars, () => (!creature.CanHaveStars) ? Toggle.Off : Toggle.On, "Can have stars", "If the creature can have stars.");
				spawnConfig<Toggle>(cfg.AttackImmediately, () => (!creature.AttackImmediately) ? Toggle.Off : Toggle.On, "Hunt player", "Makes the creature immediately hunt down the player after it spawns.");
				spawnConfig<int>(cfg.CheckSpawnInterval, () => creature.CheckSpawnInterval, "Maximum spawn interval", "Configures the timespan that Valheim has to make the creature spawn.");
				spawnConfig<float>(cfg.SpawnChance, () => creature.SpawnChance, "Spawn chance", "Sets the chance for the creature to be spawned, every time Valheim checks the spawn.");
				spawnConfig<Forest>(cfg.ForestSpawn, () => creature.ForestSpawn, "Forest condition", "If the creature can spawn in forests or cannot spawn in forests. Or both.");
				spawnConfig<int>(cfg.Maximum, () => creature.Maximum, "Maximum creature count", "The maximum number of this creature near the player, before Valheim stops spawning it in. Setting this lower than the upper limit of the group size does not make sense.");
				config<DropOption>(cfg.Drops, () => DropOption.Default, delegate
				{
					dropConfigVisibility.Browsable = cfg.Drops.get() == DropOption.Custom;
					reloadConfigDisplay();
					DropList.UpdateDrops(creature);
				}, "Drops", "Configures the drops for the creature.");
				dropConfigVisibility.Browsable = cfg.Drops.get() == DropOption.Custom;
				configWithDesc<string>(cfg.CustomDrops, [<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] () => new DropList.SerializedDrops(creature.Drops, creature).ToString(), delegate
				{
					DropList.UpdateDrops(creature);
				}, "Drop config", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { dropConfigVisibility }));
				config<Faction>(cfg.CreatureFaction, () => creature.CreatureFaction, updateCharacterAttributes, "Creature Faction", "The creature faction the creature belongs to.");
				void config<T>([<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0 })] CustomConfig<T> customConfig, [<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0 })] Func<T> getter, Action configChanged, string name, string desc)
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Expected O, but got Unknown
					configWithDesc<T>(customConfig, getter, configChanged, name, new ConfigDescription(desc, (AcceptableValueBase)null, Array.Empty<object>()));
				}
				void configWithDesc<T>([<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0 })] CustomConfig<T> customConfig, [<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0 })] Func<T> getter, Action configChanged, string name, ConfigDescription desc)
				{
					//IL_0101: Unknown result type (might be due to invalid IL or missing references)
					//IL_010b: Expected O, but got Unknown
					if (creature.ConfigurationEnabled)
					{
						customConfig.config = pluginConfig(englishName, name, getter(), new ConfigDescription(desc.Description, desc.AcceptableValues, desc.Tags.Concat(new ConfigurationManagerAttributes[1]
						{
							new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								CustomDrawer = ((customConfig == cfg.CustomDrops) ? new Action<ConfigEntryBase>(drawConfigTable) : ((typeof(T) == typeof(Range)) ? new Action<ConfigEntryBase>(drawRange) : null)),
								Category = localizedName
							}
						}).ToArray()));
						customConfig.config.SettingChanged += [<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (object _, EventArgs _) =>
						{
							configChanged();
						};
						customConfig.get = [<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] () => customConfig.config.Value;
					}
					else
					{
						customConfig.get = getter;
					}
				}
				void spawnConfig<T>([<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0 })] CustomConfig<T> customConfig, [<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(new byte[] { 1, 0 })] Func<T> getter, string name, string desc, [<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)] AcceptableValueBase acceptableValues = null)
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Expected O, but got Unknown
					configWithDesc<T>(customConfig, getter, updateAllSpawnConfigs, name, new ConfigDescription(desc, acceptableValues, new object[1] { spawnConfigVisibility }));
				}
				void updateAI()
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance))
					{
						BaseAI[] array2 = Object.FindObjectsOfType<BaseAI>();
						foreach (BaseAI ai in array2)
						{
							creature.updateAi(ai);
						}
						creature.updateAi(creature.Prefab.GetComponent<BaseAI>());
					}
				}
				void updateAllSpawnConfigs()
				{
					SpawnSystem[] array = Object.FindObjectsOfType<SpawnSystem>();
					for (int i = 0; i < array.Length; i++)
					{
						foreach (SpawnSystemList spawnList in array[i].m_spawnLists)
						{
							foreach (SpawnData spawner in spawnList.m_spawners)
							{
								if ((Object)(object)creature.Prefab == (Object)(object)spawner.m_prefab)
								{
									creature.updateSpawnData(spawner);
								}
							}
						}
					}
				}
				void updateCharacterAttributes()
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance))
					{
						creature.updateCharacterAttributes(creature.Prefab.GetComponent<Character>());
					}
				}
			}
			if (saveOnConfigSet)
			{
				plugin.Config.SaveOnConfigSet = true;
				plugin.Config.Save();
			}
			static void reloadConfigDisplay()
			{
				object obj2 = configManager?.GetType().GetProperty("DisplayingWindow").GetValue(configManager);
				if (obj2 is bool && (bool)obj2)
				{
					configManager.GetType().GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
				}
			}
		}

		private static void drawRange(ConfigEntryBase cfg)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			ConfigEntry<Range> val = (ConfigEntry<Range>)(object)cfg;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			float.TryParse(GUILayout.TextField(val.Value.min.ToString(CultureInfo.InvariantCulture), Array.Empty<GUILayoutOption>()), out var result);
			GUILayout.Label(" - ", new GUIStyle(GUI.skin.label)
			{
				fixedWidth = 14f
			}, Array.Empty<GUILayoutOption>());
			float.TryParse(GUILayout.TextField(val.Value.max.ToString(CultureInfo.InvariantCulture), Array.Empty<GUILayoutOption>()), out var result2);
			GUILayout.EndHorizontal();
			if (!valueOrDefault && (Math.Abs(val.Value.min - result) > 1E-05f || Math.Abs(val.Value.max - result2) > 1E-05f))
			{
				val.Value = new Range(result, result2);
			}
		}

		private static void drawConfigTable(ConfigEntryBase cfg)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//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_01f1: Expected O, but got Unknown
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Expected O, but got Unknown
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Expected O, but got Unknown
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Expected O, but got Unknown
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: 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_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			List<KeyValuePair<string, Drop>> list = new List<KeyValuePair<string, Drop>>();
			bool flag = false;
			int num = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
				.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			foreach (KeyValuePair<string, Drop> drop in new DropList.SerializedDrops((string)cfg.BoxedValue).Drops)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				int num2 = Mathf.RoundToInt(drop.Value.Amount.min);
				if (int.TryParse(GUILayout.TextField(num2.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result) && result != num2 && !valueOrDefault)
				{
					num2 = result;
					flag = true;
				}
				GUILayout.Label(" - ", new GUIStyle(GUI.skin.label)
				{
					fixedWidth = 14f
				}, Array.Empty<GUILayoutOption>());
				int num3 = Mathf.RoundToInt(drop.Value.Amount.max);
				if (int.TryParse(GUILayout.TextField(num3.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result2) && result2 != num3 && !valueOrDefault)
				{
					num3 = result2;
					flag = true;
				}
				GUILayout.Label(" ", new GUIStyle(GUI.skin.label)
				{
					fixedWidth = 10f
				}, Array.Empty<GUILayoutOption>());
				string text = GUILayout.TextField(drop.Key, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 35 - 14 - 35 - 10 - 21 - 18
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? drop.Key : text);
				flag = flag || text2 != drop.Key;
				bool num4 = GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault;
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				float num5 = drop.Value.DropChance;
				if (float.TryParse(GUILayout.TextField(num5.ToString(CultureInfo.InvariantCulture), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 45f
				}, Array.Empty<GUILayoutOption>()), out var result3) && Math.Abs(result3 - num5) > 1E-05f && !valueOrDefault)
				{
					num5 = result3;
					flag = true;
				}
				GUILayout.Label("% ", Array.Empty<GUILayoutOption>());
				string tooltip = GUI.tooltip;
				bool flag2 = drop.Value.MultiplyDropByLevel;
				bool flag3 = GUILayout.Toggle(flag2, new GUIContent(flag2 ? "per level" : "fixed", "Loot is multiplied by the creature's level."), Array.Empty<GUILayoutOption>());
				if (flag3 != flag2 && !valueOrDefault)
				{
					flag2 = flag3;
					flag = true;
				}
				bool flag4 = drop.Value.DropOnePerPlayer;
				bool flag5 = GUILayout.Toggle(flag4, new GUIContent(flag4 ? "per player" : "independent", "Drops one per player."), Array.Empty<GUILayoutOption>());
				if (flag5 != flag4 && !valueOrDefault)
				{
					flag4 = flag5;
					flag = true;
				}
				if (GUI.tooltip != tooltip)
				{
					Vector3 mousePosition = Input.mousePosition;
					GUI.Label(new Rect(mousePosition.x, mousePosition.y, 100f, 35f), GUI.tooltip);
				}
				if (num4)
				{
					flag = true;
				}
				else
				{
					Drop value = new Drop
					{
						Amount = new Range(num2, num3),
						DropChance = num5,
						MultiplyDropByLevel = flag2,
						DropOnePerPlayer = flag4
					};
					list.Add(new KeyValuePair<string, Drop>(text2, value));
				}
				if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
					list.Add(new KeyValuePair<string, Drop>("", new Drop()));
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new DropList.SerializedDrops(list).ToString();
			}
		}

		private void updateAi(BaseAI ai)
		{
			CreatureConfig creatureConfig = creatureConfigs[this];
			if (Object.op_Implicit((Object)(object)((Component)ai).GetComponent<Tameable>()) != (creatureConfig.CanBeTamed.get() == Toggle.On))
			{
				if (creatureConfig.CanBeTamed.get() == Toggle.On)
				{
					ai.m_tamable = ((Component)ai).gameObject.AddComponent<Tameable>();
				}
				else
				{
					Object.Destroy((Object)(object)ai.m_tamable);
					ai.m_tamable = null;
				}
			}
			Tameable tamable = ai.m_tamable;
			if (tamable != null)
			{
				tamable.m_fedDuration = creatureConfig.FedDuration.get();
				tamable.m_tamingTime = creatureConfig.TamingTime.get();
				tamable.m_startsTamed = creatureConfig.SpawnsTamed.get() == Toggle.On;
			}
			MonsterAI val = (MonsterAI)(object)((ai is MonsterAI) ? ai : null);
			if (val == null)
			{
				return;
			}
			val.m_consumeItems.Clear();
			string[] array = creatureConfig.ConsumesItemName.get().Split(new char[1] { ',' });
			foreach (string text in array)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text.Trim());
				ItemDrop val2 = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if (val2 != null)
				{
					val.m_consumeItems.Add(val2);
				}
			}
		}

		private void updateCharacterAttributes(Character character)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			CreatureConfig creatureConfig = creatureConfigs[this];
			character.m_faction = creatureConfig.CreatureFaction.get();
		}

		internal static void UpdateCreatureAis(ObjectDB __instance)
		{
			foreach (Creature registeredCreature in registeredCreatures)
			{
				registeredCreature.updateAi(registeredCreature.Prefab.GetComponent<BaseAI>());
				registeredCreature.updateCharacterAttributes(registeredCreature.Prefab.GetComponent<Character>());
			}
		}

		private void updateSpawnData(SpawnData spawnData)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			CreatureConfig cfg = creatureConfigs[this];
			spawnData.m_enabled = cfg.Spawn.get() != SpawnOption.Disabled;
			spawnData.m_biome = cfg.Biome.get();
			SpawnData val = spawnData;
			val.m_biomeArea = (BiomeArea)(cfg.SpecificSpawnArea.get() switch
			{
				SpawnArea.Center => 2, 
				SpawnArea.Edge => 1, 
				_ => 3, 
			});
			spawnData.m_maxSpawned = cfg.Maximum.get();
			spawnData.m_spawnInterval = cfg.CheckSpawnInterval.get();
			spawnData.m_spawnChance = cfg.SpawnChance.get();
			spawnData.m_requiredGlobalKey = ((InternalName)typeof(GlobalKey).GetMember(cfg.RequiredGlobalKey.get().ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName;
			spawnData.m_requiredEnvironments = (from Weather w in Enum.GetValues(typeof(Weather))
				where (w & cfg.RequiredWeather.get()) != 0
				select ((InternalName)typeof(Weather).GetMember(w.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).ToList();
			spawnData.m_groupSizeMin = (int)cfg.GroupSize.get().min;
			spawnData.m_groupSizeMax = (int)cfg.GroupSize.get().max;
			val = spawnData;
			SpawnTime spawnTime = cfg.SpecificSpawnTime.get();
			bool spawnAtNight = (uint)(spawnTime - 1) <= 1u;
			val.m_spawnAtNight = spawnAtNight;
			val = spawnData;
			spawnTime = cfg.SpecificSpawnTime.get();
			spawnAtNight = ((spawnTime == SpawnTime.Day || spawnTime == SpawnTime.Always) ? true : false);
			val.m_spawnAtDay = spawnAtNight;
			spawnData.m_minAltitude = cfg.RequiredAltitude.get().min;
			spawnData.m_maxAltitude = cfg.RequiredAltitude.get().max;
			val = spawnData;
			Forest forest = cfg.ForestSpawn.get();
			spawnAtNight = ((forest == Forest.Yes || forest == Forest.Both) ? true : false);
			val.m_inForest = spawnAtNight;
			val = spawnData;
			forest = cfg.ForestSpawn.get();
			spawnAtNight = (uint)(forest - 1) <= 1u;
			val.m_outsideForest = spawnAtNight;
			spawnData.m_minOceanDepth = cfg.RequiredOceanDepth.get().min;
			spawnData.m_maxOceanDepth = cfg.RequiredOceanDepth.get().max;
			spawnData.m_huntPlayer = cfg.AttackImmediately.get() == Toggle.On;
			spawnData.m_groundOffset = cfg.SpawnAltitude.get();
			spawnData.m_maxLevel = ((cfg.CanHaveStars.get() != 0) ? 1 : 3);
		}

		[HarmonyPriority(700)]
		internal static void AddToSpawnSystem(SpawnSystem __instance)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			SpawnSystemList val = __instance.m_spawnLists.First();
			foreach (SpawnData lastRegisteredSpawn in lastRegisteredSpawns)
			{
				val.m_spawners.Remove(lastRegisteredSpawn);
			}
			lastRegisteredSpawns.Clear();
			foreach (Creature registeredCreature in registeredCreatures)
			{
				SpawnData val2 = new SpawnData
				{
					m_name = ((Object)registeredCreature.Prefab).name,
					m_prefab = registeredCreature.Prefab
				};
				registeredCreature.updateSpawnData(val2);
				lastRegisteredSpawns.Add(val2);
				val.m_spawners.Add(val2);
			}
		}

		private static ConfigEntry<T> pluginConfig<[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> pluginConfig<[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)] T>(string group, string name, T value, string description)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return pluginConfig(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
	[PublicAPI]
	[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(1)]
	public class LocalizeKey
	{
		private static readonly List<LocalizeKey> keys = new List<LocalizeKey>();

		public readonly string Key;

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

		public LocalizeKey(string key)
		{
			Key = key.Replace("$", "");
			keys.Add(this);
		}

		public void Alias(string alias)
		{
			Localizations.Clear();
			if (!alias.Contains("$"))
			{
				alias = "$" + alias;
			}
			Localizations["alias"] = alias;
			if (Localization.m_instance != null)
			{
				Localization.instance.AddWord(Key, Localization.instance.Localize(alias));
			}
		}

		public LocalizeKey English(string key)
		{
			return addForLang("English", key);
		}

		public LocalizeKey Swedish(string key)
		{
			return addForLang("Swedish", key);
		}

		public LocalizeKey French(string key)
		{
			return addForLang("French", key);
		}

		public LocalizeKey Italian(string key)
		{
			return addForLang("Italian", key);
		}

		public LocalizeKey German(string key)
		{
			return addForLang("German", key);
		}

		public LocalizeKey Spanish(string key)
		{
			return addForLang("Spanish", key);
		}

		public LocalizeKey Russian(string key)
		{
			return addForLang("Russian", key);
		}

		public LocalizeKey Romanian(string key)
		{
			return addForLang("Romanian", key);
		}

		public LocalizeKey Bulgarian(string key)
		{
			return addForLang("Bulgarian", key);
		}

		public LocalizeKey Macedonian(string key)
		{
			return addForLang("Macedonian", key);
		}

		public LocalizeKey Finnish(string key)
		{
			return addForLang("Finnish", key);
		}

		public LocalizeKey Danish(string key)
		{
			return addForLang("Danish", key);
		}

		public LocalizeKey Norwegian(string key)
		{
			return addForLang("Norwegian", key);
		}

		public LocalizeKey Icelandic(string key)
		{
			return addForLang("Icelandic", key);
		}

		public LocalizeKey Turkish(string key)
		{
			return addForLang("Turkish", key);
		}

		public LocalizeKey Lithuanian(string key)
		{
			return addForLang("Lithuanian", key);
		}

		public LocalizeKey Czech(string key)
		{
			return addForLang("Czech", key);
		}

		public LocalizeKey Hungarian(string key)
		{
			return addForLang("Hungarian", key);
		}

		public LocalizeKey Slovak(string key)
		{
			return addForLang("Slovak", key);
		}

		public LocalizeKey Polish(string key)
		{
			return addForLang("Polish", key);
		}

		public LocalizeKey Dutch(string key)
		{
			return addForLang("Dutch", key);
		}

		public LocalizeKey Portuguese_European(string key)
		{
			return addForLang("Portuguese_European", key);
		}

		public LocalizeKey Portuguese_Brazilian(string key)
		{
			return addForLang("Portuguese_Brazilian", key);
		}

		public LocalizeKey Chinese(string key)
		{
			return addForLang("Chinese", key);
		}

		public LocalizeKey Japanese(string key)
		{
			return addForLang("Japanese", key);
		}

		public LocalizeKey Korean(string key)
		{
			return addForLang("Korean", key);
		}

		public LocalizeKey Hindi(string key)
		{
			return addForLang("Hindi", key);
		}

		public LocalizeKey Thai(string key)
		{
			return addForLang("Thai", key);
		}

		public LocalizeKey Abenaki(string key)
		{
			return addForLang("Abenaki", key);
		}

		public LocalizeKey Croatian(string key)
		{
			return addForLang("Croatian", key);
		}

		public LocalizeKey Georgian(string key)
		{
			return addForLang("Georgian", key);
		}

		public LocalizeKey Greek(string key)
		{
			return addForLang("Greek", key);
		}

		public LocalizeKey Serbian(string key)
		{
			return addForLang("Serbian", key);
		}

		public LocalizeKey Ukrainian(string key)
		{
			return addForLang("Ukrainian", key);
		}

		private LocalizeKey addForLang(string lang, string value)
		{
			Localizations[lang] = value;
			if (Localization.m_instance != null)
			{
				if (Localization.instance.GetSelectedLanguage() == lang)
				{
					Localization.instance.AddWord(Key, value);
				}
				else if (lang == "English" && !Localization.instance.m_translations.ContainsKey(Key))
				{
					Localization.instance.AddWord(Key, value);
				}
			}
			return this;
		}

		[HarmonyPriority(300)]
		internal static void AddLocalizedKeys(Localization __instance, string language)
		{
			foreach (LocalizeKey key in keys)
			{
				string value2;
				if (key.Localizations.TryGetValue(language, out var value) || key.Localizations.TryGetValue("English", out value))
				{
					__instance.AddWord(key.Key, value);
				}
				else if (key.Localizations.TryGetValue("alias", out value2))
				{
					__instance.AddWord(key.Key, Localization.instance.Localize(value2));
				}
			}
		}
	}
	[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
	[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(1)]
	public static class LocalizationCache
	{
		private static readonly Dictionary<string, Localization> localizations = new Dictionary<string, Localization>();

		internal static void LocalizationPostfix(Localization __instance, string language)
		{
			string key = localizations.FirstOrDefault([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (KeyValuePair<string, Localization> l) => l.Value == __instance).Key;
			if (key != null)
			{
				localizations.Remove(key);
			}
			if (!localizations.ContainsKey(language))
			{
				localizations.Add(language, __instance);
			}
		}

		public static Localization ForLanguage([<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(2)] string language = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (localizations.TryGetValue(language ?? PlayerPrefs.GetString("language", "English"), out var value))
			{
				return value;
			}
			value = new Localization();
			if (language != null)
			{
				value.SetupLanguage(language);
			}
			return value;
		}
	}
	[<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(1)]
	[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
	public static class PrefabManager
	{
		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(0)]
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		private static readonly List<GameObject> prefabs;

		static PrefabManager()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			prefabs = new List<GameObject>();
			Harmony val = new Harmony("org.bepinex.helpers.CreatureManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature.DropList), "AddDropsToCreature", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(SpawnSystem), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature), "AddToSpawnSystem", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature), "UpdateCreatureAis", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizeKey), "AddLocalizedKeys", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizationCache), "LocalizationPostfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			if (!typeof(Biome).GetCustomAttributes(typeof(FlagsAttribute), inherit: false).Any())
			{
				val.Patch((MethodBase)AccessTools.Method(typeof(Biome).GetType(), "GetCustomAttributes", new Type[2]
				{
					typeof(Type),
					typeof(bool)
				}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "BiomeIsFlags", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void BiomeIsFlags(Type __instance, Type attributeType, ref object[] __result)
		{
			if (__instance == typeof(Biome) && attributeType == typeof(FlagsAttribute))
			{
				__result = new object[1]
				{
					new FlagsAttribute()
				};
			}
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId bundleId = default(BundleId);
			bundleId.assetBundleFileName = assetBundleFileName;
			bundleId.folderName = folderName;
			BundleId key = bundleId;
			if (!bundleCache.TryGetValue(key, out var value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)([<e05aac32-07e8-4eb0-b65d-e88037d1bf1a>NullableContext(0)] (AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static GameObject RegisterPrefab(AssetBundle assets, string prefabName)
		{
			GameObject val = assets.LoadAsset<GameObject>(prefabName);
			prefabs.Add(val);
			return val;
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (GameObject prefab in prefabs)
			{
				__instance.m_prefabs.Add(prefab);
			}
		}
	}
	public static class CreatureManagerVersion
	{
		[<3e938731-0684-4af9-b1cb-6949668ce29c>Nullable(1)]
		public const string Version = "1.12.0";
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<864a6273-cc12-4191-84f8-d4a28dfb5dd8>Embedded]
	internal sealed class <864a6273-cc12-4191-84f8-d4a28dfb5dd8>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<864a6273-cc12-4191-84f8-d4a28dfb5dd8>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <24bda780-98ea-45eb-92e7-a69ed9c4deaf>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <24bda780-98ea-45eb-92e7-a69ed9c4deaf>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <24bda780-98ea-45eb-92e7-a69ed9c4deaf>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<864a6273-cc12-4191-84f8-d4a28dfb5dd8>Embedded]
	[CompilerGenerated]
	internal sealed class <f31c858f-f204-4312-8ce3-b936e109315d>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <f31c858f-f204-4312-8ce3-b936e109315d>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[<864a6273-cc12-4191-84f8-d4a28dfb5dd8>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class <a5685ac3-5f94-4b88-91ca-90f1233136b2>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <a5685ac3-5f94-4b88-91ca-90f1233136b2>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
	[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(0)]
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(2)]
		public object LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(0)]
	[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
	internal class SyncedConfigEntry<[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(2)] T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
			base..ctor();
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(0)]
	[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(2)]
	internal abstract class CustomSyncedValueBase
	{
		public object LocalBaseValue;

		[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(1)]
		public readonly string Identifier;

		[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(1)]
		public readonly Type Type;

		private object boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action ValueChanged;

		[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
	[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(0)]
	internal sealed class CustomSyncedValue<[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(2)] T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(0)]
	[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
	internal class ConfigSync
	{
		[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(0)]
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(2)]
			public static ZRpc currentRpc;

			[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(0)]
		internal static class RegisterRPCPatch
		{
			[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(1)]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		[<f31c858f-f204-4312-8ce3-b936e109315d>NullableContext(0)]
		private class ParsedConfigs
		{
			[<24bda780-98ea-45eb-92e7-a69ed9c4deaf>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();

			[<24bda780-98ea-