using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Extensions;
using Jotunn.Managers;
using Jotunn.Utils;
using MonoMod.Utils;
using SimpleJson;
using Splatform;
using StarLevelSystem.Data;
using StarLevelSystem.Modifiers;
using StarLevelSystem.common;
using StarLevelSystem.modules;
using StarLevelSystem.modules.AnimationAndSpeed;
using StarLevelSystem.modules.CreatureSetup;
using StarLevelSystem.modules.Damage;
using StarLevelSystem.modules.Health;
using StarLevelSystem.modules.LevelSystem;
using StarLevelSystem.modules.Loot;
using StarLevelSystem.modules.Modifiers;
using StarLevelSystem.modules.NemesisSystem;
using StarLevelSystem.modules.Raids;
using StarLevelSystem.modules.Sizes;
using StarLevelSystem.modules.UI;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("StarLevelSystem")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("StarLevelSystem")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("1.4.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.0.0")]
[CompilerGenerated]
internal delegate void <>f__AnonymousDelegate0<T1, T2, T3>(T1 arg1 = default(T1), T2 arg2 = default(T2), T3 arg3 = default(T3));
namespace StarLevelSystem
{
	[PublicAPI]
	public static class API
	{
		private static readonly Type APIReciever;

		private static readonly MethodInfo UpdateCreatureLevel;

		private static readonly MethodInfo UpdateCreatureColorization;

		private static readonly MethodInfo GetBaseAttributeValue;

		private static readonly MethodInfo UpdateCreatureBaseAttributes;

		private static readonly MethodInfo GetAllBaseAttributeValues;

		private static readonly MethodInfo SetAllBaseAttributeValues;

		private static readonly MethodInfo GetPerLevelAttributeValue;

		private static readonly MethodInfo UpdateCreaturePerLevelAttributes;

		private static readonly MethodInfo GetAllPerLevelAttributeValues;

		private static readonly MethodInfo SetAllPerLevelAttributeValues;

		private static readonly MethodInfo GetCreatureDamageRecievedModifier;

		private static readonly MethodInfo UpdateCreatureDamageRecievedModifier;

		private static readonly MethodInfo GetAllDamageRecievedModifiers;

		private static readonly MethodInfo SetAllDamageRecievedModifiers;

		private static readonly MethodInfo GetCreatureDamageBonus;

		private static readonly MethodInfo UpdateCreatureDamageBonus;

		private static readonly MethodInfo GetAllDamageBonus;

		private static readonly MethodInfo SetAllDamageBonus;

		private static readonly MethodInfo ApplyUpdatesToCreature;

		private static readonly MethodInfo GetPossibleModifiersForType;

		private static readonly MethodInfo GetAllModifiersForCreature;

		private static readonly MethodInfo AddModifierToCreature;

		private static readonly MethodInfo AddNewModifierToSLS;

		public static bool IsAvailable => APIReciever != null;

		static API()
		{
			APIReciever = Type.GetType("StarLevelSystem.modules.APIReciever, StarLevelSystem");
			if (!(APIReciever == null))
			{
				UpdateCreatureLevel = APIReciever.GetMethod("UpdateCreatureLevel", BindingFlags.Static | BindingFlags.Public);
				UpdateCreatureColorization = APIReciever.GetMethod("UpdateCreatureColorization", BindingFlags.Static | BindingFlags.Public);
				GetBaseAttributeValue = APIReciever.GetMethod("GetBaseAttributeValue", BindingFlags.Static | BindingFlags.Public);
				UpdateCreatureBaseAttributes = APIReciever.GetMethod("UpdateCreatureBaseAttributes", BindingFlags.Static | BindingFlags.Public);
				GetAllBaseAttributeValues = APIReciever.GetMethod("GetAllBaseAttributeValues", BindingFlags.Static | BindingFlags.Public);
				SetAllBaseAttributeValues = APIReciever.GetMethod("SetAllBaseAttributeValues", BindingFlags.Static | BindingFlags.Public);
				GetPerLevelAttributeValue = APIReciever.GetMethod("GetPerLevelAttributeValue", BindingFlags.Static | BindingFlags.Public);
				UpdateCreaturePerLevelAttributes = APIReciever.GetMethod("UpdateCreaturePerLevelAttributes", BindingFlags.Static | BindingFlags.Public);
				GetAllPerLevelAttributeValues = APIReciever.GetMethod("GetAllPerLevelAttributeValues", BindingFlags.Static | BindingFlags.Public);
				SetAllPerLevelAttributeValues = APIReciever.GetMethod("SetAllPerLevelAttributeValues", BindingFlags.Static | BindingFlags.Public);
				GetCreatureDamageRecievedModifier = APIReciever.GetMethod("GetCreatureDamageRecievedModifier", BindingFlags.Static | BindingFlags.Public);
				UpdateCreatureDamageRecievedModifier = APIReciever.GetMethod("UpdateCreatureDamageRecievedModifier", BindingFlags.Static | BindingFlags.Public);
				GetAllDamageRecievedModifiers = APIReciever.GetMethod("GetAllDamageRecievedModifiers", BindingFlags.Static | BindingFlags.Public);
				SetAllDamageRecievedModifiers = APIReciever.GetMethod("SetAllDamageRecievedModifiers", BindingFlags.Static | BindingFlags.Public);
				GetCreatureDamageBonus = APIReciever.GetMethod("GetCreatureDamageBonus", BindingFlags.Static | BindingFlags.Public);
				UpdateCreatureDamageBonus = APIReciever.GetMethod("UpdateCreatureDamageBonus", BindingFlags.Static | BindingFlags.Public);
				GetAllDamageBonus = APIReciever.GetMethod("GetAllDamageBonus", BindingFlags.Static | BindingFlags.Public);
				SetAllDamageBonus = APIReciever.GetMethod("SetAllDamageBonus", BindingFlags.Static | BindingFlags.Public);
				ApplyUpdatesToCreature = APIReciever.GetMethod("ApplyUpdatesToCreature", BindingFlags.Static | BindingFlags.Public);
				GetPossibleModifiersForType = APIReciever.GetMethod("GetPossibleModifiersForType", BindingFlags.Static | BindingFlags.Public);
				GetAllModifiersForCreature = APIReciever.GetMethod("GetAllModifiersForCreature", BindingFlags.Static | BindingFlags.Public);
				AddModifierToCreature = APIReciever.GetMethod("AddModifierToCreature", BindingFlags.Static | BindingFlags.Public);
				AddNewModifierToSLS = APIReciever.GetMethod("AddNewModifierToSLS", BindingFlags.Static | BindingFlags.Public);
			}
		}

		public static bool SetCreatureLevel(Character creatureId, int newLevel)
		{
			return (bool)UpdateCreatureLevel.Invoke(null, new object[2] { creatureId, newLevel });
		}

		public static bool SetCreatureColorization(Character creatureId, float value, float hue, float sat, bool emission = false)
		{
			return (bool)UpdateCreatureColorization.Invoke(null, new object[5] { creatureId, value, hue, sat, emission });
		}

		public static float GetCreatureBaseAttribute(Character creatureId, int attribute)
		{
			return (float)GetBaseAttributeValue.Invoke(null, new object[2] { creatureId, attribute });
		}

		public static bool SetCreatureBaseAttribute(Character creatureId, int attribute, float value)
		{
			return (bool)UpdateCreatureBaseAttributes.Invoke(null, new object[3] { creatureId, attribute, value });
		}

		public static Dictionary<int, float> GetAllCreatureBaseAttributes(Character creatureId)
		{
			return (Dictionary<int, float>)GetAllBaseAttributeValues.Invoke(null, new object[1] { creatureId });
		}

		public static bool SetAllCreatureBaseAttributes(Character creatureId, Dictionary<int, float> attributes)
		{
			return (bool)SetAllBaseAttributeValues.Invoke(null, new object[2] { creatureId, attributes });
		}

		public static float GetCreaturePerLevelAttribute(Character creatureId, int attribute)
		{
			return (float)GetPerLevelAttributeValue.Invoke(null, new object[2] { creatureId, attribute });
		}

		public static bool SetCreaturePerLevelAttribute(Character creatureId, int attribute, float value)
		{
			return (bool)UpdateCreaturePerLevelAttributes.Invoke(null, new object[3] { creatureId, attribute, value });
		}

		public static Dictionary<int, float> GetAllCreaturePerLevelAttributes(Character creatureId)
		{
			return (Dictionary<int, float>)GetAllPerLevelAttributeValues.Invoke(null, new object[1] { creatureId });
		}

		public static bool SetAllCreaturePerLevelAttributes(Character creatureId, Dictionary<int, float> attributes)
		{
			return (bool)SetAllPerLevelAttributeValues.Invoke(null, new object[2] { creatureId, attributes });
		}

		public static float GetCreatureDamageReceivedModifier(Character creatureId, int damageType)
		{
			return (float)GetCreatureDamageRecievedModifier.Invoke(null, new object[2] { creatureId, damageType });
		}

		public static bool SetCreatureDamageReceivedModifier(Character creatureId, int damageType, float value)
		{
			return (bool)UpdateCreatureDamageRecievedModifier.Invoke(null, new object[3] { creatureId, damageType, value });
		}

		public static Dictionary<int, float> GetAllCreatureDamageReceivedModifiers(Character creatureId)
		{
			return (Dictionary<int, float>)GetAllDamageRecievedModifiers.Invoke(null, new object[1] { creatureId });
		}

		public static bool SetAllCreatureDamageReceivedModifiers(Character creatureId, Dictionary<int, float> attributes)
		{
			return (bool)SetAllDamageRecievedModifiers.Invoke(null, new object[2] { creatureId, attributes });
		}

		public static float GetCreatureFlatDamageBonus(Character creatureId, int damageType)
		{
			return (float)GetCreatureDamageBonus.Invoke(null, new object[2] { creatureId, damageType });
		}

		public static bool SetCreatureFlatDamageBonus(Character creatureId, int damageType, float value)
		{
			return (bool)UpdateCreatureDamageBonus.Invoke(null, new object[3] { creatureId, damageType, value });
		}

		public static Dictionary<int, float> GetAllCreatureFlatDamageBonuses(Character creatureId)
		{
			return (Dictionary<int, float>)GetAllDamageBonus.Invoke(null, new object[1] { creatureId });
		}

		public static bool SetAllCreatureFlatDamageBonuses(Character creatureId, Dictionary<int, float> attributes)
		{
			return (bool)SetAllDamageBonus.Invoke(null, new object[2] { creatureId, attributes });
		}

		public static bool ApplyCreatureUpdates(Character creatureId)
		{
			return (bool)ApplyUpdatesToCreature.Invoke(null, new object[1] { creatureId });
		}

		public static List<string> GetPossibleModifiers(int modType = 0)
		{
			return (List<string>)GetPossibleModifiersForType.Invoke(null, new object[1] { modType });
		}

		public static Dictionary<string, int> GetCreaturesModifiers(Character creatureId)
		{
			return (Dictionary<string, int>)GetAllModifiersForCreature.Invoke(null, new object[1] { creatureId });
		}

		public static bool AddModifierToTargetCreature(Character creatureId, string modifierName, int modifierType, bool update = true)
		{
			return (bool)AddModifierToCreature.Invoke(null, new object[4] { creatureId, modifierName, modifierType, update });
		}

		public static bool AddNewModifier(int modifierID, string modifier_name, Delegate setupMethod = null, float selectionWeight = 10f, float basepower = 0f, float perlevelpower = 0f, Dictionary<Biome, List<string>> biomeConfig = null, int namingStyle = 2, string name_suffixes = null, string name_prefixes = null, int visualStyle = 0, Sprite starIcon = null, GameObject visualEffect = null, List<string> allowed_creatures = null, List<string> unallowed_creatures = null, List<Biome> allowed_biomes = null)
		{
			return (bool)AddNewModifierToSLS.Invoke(null, new object[16]
			{
				modifierID, modifier_name, setupMethod, selectionWeight, basepower, perlevelpower, biomeConfig, namingStyle, name_suffixes, name_prefixes,
				visualStyle, starIcon, visualEffect, allowed_creatures, unallowed_creatures, allowed_biomes
			});
		}
	}
	internal static class Logger
	{
		public static LogLevel Level = (LogLevel)16;

		public static void EnableDebugLogging(object sender, EventArgs e)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (ValConfig.EnableDebugMode.Value)
			{
				Level = (LogLevel)32;
			}
			else
			{
				Level = (LogLevel)16;
			}
		}

		public static void CheckEnableDebugLogging()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (ValConfig.EnableDebugMode.Value)
			{
				Level = (LogLevel)32;
			}
			else
			{
				Level = (LogLevel)16;
			}
		}

		public static void LogNemesis(string message)
		{
			if (ValConfig.EnableDebugNemesisDetails.Value)
			{
				StarLevelSystem.Log.LogInfo((object)("[Nemesis] " + message));
			}
		}

		public static void LogRaid(string message)
		{
			if (ValConfig.EnableDebugRaidDetails.Value)
			{
				StarLevelSystem.Log.LogInfo((object)("[Raid] " + message));
			}
		}

		public static void LogLoot(string message)
		{
			if (ValConfig.EnableDebugLootDetails.Value)
			{
				StarLevelSystem.Log.LogInfo((object)("[Loot] " + message));
			}
		}

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

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

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

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

		public const string PluginName = "StarLevelSystem";

		public const string PluginVersion = "1.4.0";

		public ValConfig cfg;

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

		public static AssetBundle EmbeddedResourceBundle;

		public static ManualLogSource Log;

		public static Harmony HarmonyInstance { get; private set; }

		public void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			cfg = new ValConfig(((BaseUnityPlugin)this).Config);
			cfg.SetupConfigRPCs();
			cfg.LoadYamlConfigs();
			TaskRunner.Setup();
			Compatibility.CheckModCompat();
			EmbeddedResourceBundle = AssetUtils.LoadAssetBundleFromResources("StarLevelSystem.assets.starlevelsystems", typeof(StarLevelSystem).Assembly);
			HarmonyInstance = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "MidnightsFX.StarLevelSystem");
			Compatibility.ApplyConditionalPatches(HarmonyInstance);
			Colorization.Init();
			LevelSystemData.Init();
			LootSystemData.Init();
			CreatureModifiersData.Init();
			RaidsData.Init();
			NemesisSystemData.Init();
			QuickConfigureTool.Init();
			LocalizationLoader.AddLocalizations();
			PrefabManager.OnVanillaPrefabsAvailable += CreatureModifiersData.LoadPrefabs;
			PrefabManager.OnVanillaPrefabsAvailable += UpdateLevelsOnChange.UpdateFishMaxLevel;
			PrefabManager.OnVanillaPrefabsAvailable += UIHudControl.SetDefaultStar;
			PrefabManager.OnVanillaPrefabsAvailable += NemesisRemoteSpawnControl.LoadAssets;
			PrefabManager.OnPrefabsRegistered += LootSystemData.AttachPrefabsWhenReady;
			MinimapManager.OnVanillaMapDataLoaded += DistanceScaleSystem.DelayedMinimapSetup;
			MinimapManager.OnVanillaMapDataLoaded += ZoneScaleSystem.Initialize;
			MinimapManager.OnVanillaMapDataLoaded += NemesisMinimap.OnMapReady;
			PrefabManager.OnPrefabsRegistered += SizeModifications.PrepareSizeRefCache;
			SynchronizationManager.OnConfigurationSynchronized += delegate
			{
				ValConfig.HasServerUpdates();
			};
			UIHudControl.LoadAssets();
			RaidControl.LoadAssets();
			TerminalCommands.AddCommands();
			NemesisSystem.Initialize();
			ConfigFileWatcher.Initialize();
		}
	}
}
namespace StarLevelSystem.modules
{
	public static class APIReciever
	{
		public static bool UpdateCreatureLevel(Character chara, int level)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			Logger.LogDebug($"SLS-API: Update Creature level {chara} - {level}");
			LevelSelection.SetAndUpdateCharacterLevel(chara, level);
			return true;
		}

		public static bool UpdateCreatureColorization(Character chara, float value, float hue, float sat, bool emission = false)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(chara);
			if (cacheEntry == null)
			{
				return false;
			}
			cacheEntry.Colorization = Colorization.DetermineCharacterColorization(chara, chara.m_level);
			CompositeLazyCache.UpdateCharacterCacheEntry(chara, cacheEntry);
			Colorization.ApplyColorizationWithoutLevelEffects(((Component)chara).gameObject, cacheEntry.Colorization);
			return true;
		}

		public static float GetBaseAttributeValue(Character chara, int attribute)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return -1f;
			}
			return CompositeLazyCache.GetAndSetLocalCache(chara)?.CreatureBaseValueModifiers[(DataObjects.CreatureBaseAttribute)attribute] ?? (-1f);
		}

		public static bool UpdateCreatureBaseAttributes(Character chara, int attribute, float value)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return false;
			}
			andSetLocalCache.CreatureBaseValueModifiers[(DataObjects.CreatureBaseAttribute)attribute] = value;
			if (attribute == 4)
			{
				SizeModifications.SetSizeModification(((Component)chara).gameObject, chara.m_nview, andSetLocalCache, update: true);
			}
			return true;
		}

		public static Dictionary<int, float> GetAllBaseAttributes(Character chara)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return null;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return null;
			}
			Dictionary<int, float> dictionary = new Dictionary<int, float>();
			foreach (KeyValuePair<DataObjects.CreatureBaseAttribute, float> creatureBaseValueModifier in andSetLocalCache.CreatureBaseValueModifiers)
			{
				dictionary[(int)creatureBaseValueModifier.Key] = creatureBaseValueModifier.Value;
			}
			return dictionary;
		}

		public static bool SetAllBaseAttributes(Character chara, Dictionary<int, float> attributes)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return false;
			}
			foreach (KeyValuePair<int, float> attribute in attributes)
			{
				andSetLocalCache.CreatureBaseValueModifiers[(DataObjects.CreatureBaseAttribute)attribute.Key] = attribute.Value;
			}
			CompositeLazyCache.UpdateCharacterCacheEntry(chara, andSetLocalCache);
			SpeedModifications.ApplySpeedModifications(chara, andSetLocalCache);
			DamageModifications.ApplyDamageModification(chara, andSetLocalCache);
			SizeModifications.SetSizeModification(((Component)chara).gameObject, chara.m_nview, andSetLocalCache, update: true);
			HealthModifications.ForceApplyHealthModifications(chara, andSetLocalCache);
			return true;
		}

		public static float GetPerLevelAttributeValue(Character chara, int attribute)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return -1f;
			}
			return CompositeLazyCache.GetAndSetLocalCache(chara)?.CreaturePerLevelValueModifiers[(DataObjects.CreaturePerLevelAttribute)attribute] ?? (-1f);
		}

		public static bool UpdateCreaturePerLevelAttributes(Character chara, int attribute, float value)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return false;
			}
			andSetLocalCache.CreaturePerLevelValueModifiers[(DataObjects.CreaturePerLevelAttribute)attribute] = value;
			if (attribute == 4)
			{
				SizeModifications.SetSizeModification(((Component)chara).gameObject, chara.m_nview, andSetLocalCache, update: true);
			}
			return true;
		}

		public static Dictionary<int, float> GetAllPerLevelAttributes(Character chara)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return null;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return null;
			}
			Dictionary<int, float> dictionary = new Dictionary<int, float>();
			foreach (KeyValuePair<DataObjects.CreaturePerLevelAttribute, float> creaturePerLevelValueModifier in andSetLocalCache.CreaturePerLevelValueModifiers)
			{
				dictionary[(int)creaturePerLevelValueModifier.Key] = creaturePerLevelValueModifier.Value;
			}
			return dictionary;
		}

		public static bool SetAllPerLevelAttributes(Character chara, Dictionary<int, float> attributes)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return false;
			}
			foreach (KeyValuePair<int, float> attribute in attributes)
			{
				andSetLocalCache.CreaturePerLevelValueModifiers[(DataObjects.CreaturePerLevelAttribute)attribute.Key] = attribute.Value;
			}
			CompositeLazyCache.UpdateCharacterCacheEntry(chara, andSetLocalCache);
			SpeedModifications.ApplySpeedModifications(chara, andSetLocalCache);
			DamageModifications.ApplyDamageModification(chara, andSetLocalCache);
			SizeModifications.SetSizeModification(((Component)chara).gameObject, chara.m_nview, andSetLocalCache, update: true);
			HealthModifications.ForceApplyHealthModifications(chara, andSetLocalCache);
			return true;
		}

		public static float GetCreatureDamageRecievedModifier(Character chara, int attribute)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return -1f;
			}
			return CompositeLazyCache.GetAndSetLocalCache(chara)?.DamageRecievedModifiers[(DataObjects.DamageType)attribute] ?? (-1f);
		}

		public static bool UpdateCreatureDamageRecievedModifier(Character chara, int attribute, float value)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return false;
			}
			andSetLocalCache.DamageRecievedModifiers[(DataObjects.DamageType)attribute] = value;
			return true;
		}

		public static Dictionary<int, float> GetAllDamageRecievedModifiers(Character chara)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return null;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return null;
			}
			Dictionary<int, float> dictionary = new Dictionary<int, float>();
			foreach (KeyValuePair<DataObjects.DamageType, float> damageRecievedModifier in andSetLocalCache.DamageRecievedModifiers)
			{
				dictionary[(int)damageRecievedModifier.Key] = damageRecievedModifier.Value;
			}
			return dictionary;
		}

		public static bool SetAllDamageRecievedModifiers(Character chara, Dictionary<int, float> attributes)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return false;
			}
			foreach (KeyValuePair<int, float> attribute in attributes)
			{
				andSetLocalCache.DamageRecievedModifiers[(DataObjects.DamageType)attribute.Key] = attribute.Value;
			}
			CompositeLazyCache.UpdateCharacterCacheEntry(chara, andSetLocalCache);
			DamageModifications.ApplyDamageModification(chara, andSetLocalCache);
			return true;
		}

		public static float GetCreatureDamageBonus(Character chara, int attribute)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return -1f;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return -1f;
			}
			if (andSetLocalCache.CreatureDamageBonus.ContainsKey((DataObjects.DamageType)attribute))
			{
				return andSetLocalCache.CreatureDamageBonus[(DataObjects.DamageType)attribute];
			}
			return 0f;
		}

		public static bool UpdateCreatureDamageBonus(Character chara, int attribute, float value)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return false;
			}
			if (!andSetLocalCache.CreatureDamageBonus.ContainsKey((DataObjects.DamageType)attribute))
			{
				andSetLocalCache.CreatureDamageBonus[(DataObjects.DamageType)attribute] = value;
			}
			else
			{
				andSetLocalCache.CreatureDamageBonus.Add((DataObjects.DamageType)attribute, value);
			}
			return true;
		}

		public static Dictionary<int, float> GetAllDamageBonus(Character chara)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return null;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return null;
			}
			Dictionary<int, float> dictionary = new Dictionary<int, float>();
			foreach (KeyValuePair<DataObjects.DamageType, float> creatureDamageBonu in andSetLocalCache.CreatureDamageBonus)
			{
				dictionary[(int)creatureDamageBonu.Key] = creatureDamageBonu.Value;
			}
			return dictionary;
		}

		public static bool SetAllDamageBonus(Character chara, Dictionary<int, float> attributes)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return false;
			}
			foreach (KeyValuePair<int, float> attribute in attributes)
			{
				andSetLocalCache.CreatureDamageBonus[(DataObjects.DamageType)attribute.Key] = attribute.Value;
			}
			CompositeLazyCache.UpdateCharacterCacheEntry(chara, andSetLocalCache);
			DamageModifications.ApplyDamageModification(chara, andSetLocalCache);
			return true;
		}

		public static bool ApplyUpdatesToCreature(Character chara)
		{
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara);
			if (andSetLocalCache == null)
			{
				return false;
			}
			SpeedModifications.ApplySpeedModifications(chara, andSetLocalCache);
			DamageModifications.ApplyDamageModification(chara, andSetLocalCache);
			SizeModifications.SetSizeModification(((Component)chara).gameObject, chara.m_nview, andSetLocalCache, update: true);
			HealthModifications.ForceApplyHealthModifications(chara, andSetLocalCache);
			return true;
		}

		public static List<string> GetPossibleModifiersForType(int modifierType)
		{
			List<string> list = new List<string>();
			switch (modifierType)
			{
			case 0:
				foreach (string key in CreatureModifiersData.ActiveCreatureModifiers.MajorModifiers.Keys)
				{
					list.Add(key);
				}
				break;
			case 1:
				foreach (string key2 in CreatureModifiersData.ActiveCreatureModifiers.MinorModifiers.Keys)
				{
					list.Add(key2);
				}
				break;
			case 2:
				foreach (string key3 in CreatureModifiersData.ActiveCreatureModifiers.BossModifiers.Keys)
				{
					list.Add(key3);
				}
				break;
			default:
				Logger.LogWarning($"Invalid modifier type {modifierType} passed to GetAllPossibleModifiers. Valid types are 0 (Major), 1 (Minor), 2 (Boss).");
				break;
			}
			return list;
		}

		public static Dictionary<string, int> GetAllModifiersForCreature(Character chara)
		{
			Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(chara);
			if (creatureModifiers == null)
			{
				return null;
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (KeyValuePair<string, DataObjects.ModifierType> item in creatureModifiers)
			{
				dictionary.Add(item.Key.ToString(), (int)item.Value);
			}
			return dictionary;
		}

		public static bool AddModifierToCreature(Character chara, string modifierName, int modifierType, bool update = true)
		{
			if (CompositeLazyCache.GetAndSetLocalCache(chara) == null)
			{
				return false;
			}
			return CreatureModifiers.AddCreatureModifier(chara, (DataObjects.ModifierType)modifierType, modifierName, update);
		}

		public static bool AddNewModifierToSLS(int modifierID, string modifier_name, Delegate setupMethod = null, float selectionWeight = 10f, float basepower = 0f, float perlevelpower = 0f, Dictionary<Biome, List<string>> biomeConfig = null, int namingStyle = 2, string name_suffixes = null, string name_prefixes = null, int visualStyle = 0, Sprite starIcon = null, GameObject visualEffect = null, List<string> allowed_creatures = null, List<string> unallowed_creatures = null, List<Biome> allowed_biomes = null)
		{
			if (CreatureModifiersData.ModifierNamesLookupTable.ContainsID(modifierID))
			{
				Logger.LogWarning($"Modifier ID {modifierID} already exists as {CreatureModifiersData.ModifierNamesLookupTable.GetValue(modifierID)}, please choose a different ID");
				return false;
			}
			CreatureModifiersData.ModifierNamesLookupTable.AddValue(modifier_name, modifierID);
			DataObjects.CreatureModifierDefinition creatureModifierDefinition = new DataObjects.CreatureModifierDefinition();
			if ((Object)(object)starIcon != (Object)null)
			{
				creatureModifierDefinition.StarVisualAPI = starIcon;
				creatureModifierDefinition.StarVisual = ((Object)starIcon).name;
			}
			if ((Object)(object)visualEffect != (Object)null)
			{
				creatureModifierDefinition.VisualEffectAPI = visualEffect;
				creatureModifierDefinition.VisualEffect = ((Object)visualEffect).name;
			}
			if ((object)setupMethod != null)
			{
				creatureModifierDefinition.SetupEvent = setupMethod;
			}
			if (name_suffixes != null)
			{
				creatureModifierDefinition.NameSuffix = name_suffixes;
			}
			if (name_prefixes != null)
			{
				creatureModifierDefinition.NamePrefix = name_prefixes;
			}
			if (namingStyle > 2 || namingStyle < 0)
			{
				namingStyle = 2;
			}
			creatureModifierDefinition.NamingConvention = (DataObjects.NameSelectionStyle)namingStyle;
			if (visualStyle > 3 || visualStyle < 0)
			{
				visualStyle = 0;
			}
			creatureModifierDefinition.VisualEffectStyle = (DataObjects.VisualEffectStyle)visualStyle;
			DataObjects.CreatureModifierConfiguration creatureModifierConfiguration = new DataObjects.CreatureModifierConfiguration();
			creatureModifierConfiguration.Config = new DataObjects.CreatureModConfig
			{
				BasePower = basepower,
				PerlevelPower = perlevelpower,
				BiomeObjects = biomeConfig
			};
			creatureModifierConfiguration.SelectionWeight = selectionWeight;
			if (allowed_creatures != null)
			{
				creatureModifierConfiguration.AllowedCreatures = allowed_creatures;
			}
			if (unallowed_creatures != null)
			{
				creatureModifierConfiguration.UnallowedCreatures = unallowed_creatures;
			}
			if (allowed_biomes != null)
			{
				creatureModifierConfiguration.AllowedBiomes = allowed_biomes;
			}
			CreatureModifiersData.ClearProbabilityCaches();
			return true;
		}
	}
	public static class Colorization
	{
		[HarmonyPatch(typeof(LevelEffects), "SetupLevelVisualization")]
		public static class PreventDefaultLevelSetup
		{
			public static bool Prefix()
			{
				return false;
			}
		}

		public static DataObjects.CreatureColorizationSettings creatureColorizationSettings = defaultColorizationSettings;

		private static DataObjects.CreatureColorizationSettings defaultColorizationSettings = new DataObjects.CreatureColorizationSettings
		{
			CharacterSpecificColorization = ColorizationData.characterColorizationData,
			DefaultLevelColorization = ColorizationData.defaultColorizationData,
			CharacterColorGenerators = ColorizationData.defaultColorGenerators
		};

		public static List<Color> mapRingColors = new List<Color>();

		public static List<Color> zoneOverlayColors = new List<Color>();

		public static readonly Dictionary<string, string> defaultColors = new Dictionary<string, string>
		{
			{ "Red", "#ff1a1a" },
			{ "Orange", "#ff9933" },
			{ "Yellow", "#ffff1a" },
			{ "Green", "#50f83a" },
			{ "Teal", "#18e7a9" },
			{ "Blue", "#00abff" },
			{ "Purple", "#c966ff" },
			{ "Pink", "#ff4dcf" },
			{ "Gray", "#999999" },
			{ "Brown", "#b37700" },
			{ "Black", "#333333" },
			{ "White", "#f2f2f2" },
			{ "LightYellow", "#ffff99" },
			{ "LightOrange", "#ffc266" },
			{ "DarkOrange", "#cc6600" },
			{ "LightRed", "#ff6666" },
			{ "DarkRed", "#b30000" },
			{ "LightPurple", "#e0b3ff" },
			{ "DarkPurple", "#8000b3" }
		};

		public static DataObjects.ColorDef defaultColorization = new DataObjects.ColorDef
		{
			Hue = 0f,
			Saturation = 0f,
			Value = 0f,
			IsEmissive = false
		};

		public static void Init()
		{
			creatureColorizationSettings = defaultColorizationSettings;
			try
			{
				UpdateYamlConfig(File.ReadAllText(ValConfig.colorsFilePath));
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"There was an error updating the Color Level values, defaults will be used. Exception: {arg}");
			}
		}

		public static string YamlDefaultConfig()
		{
			return DataObjects.yamlSerializer.Serialize((object)defaultColorizationSettings);
		}

		public static bool UpdateYamlConfig(string yaml)
		{
			try
			{
				Colorization.creatureColorizationSettings = DataObjects.yamlDeserializer.Deserialize<DataObjects.CreatureColorizationSettings>(yaml);
				foreach (KeyValuePair<int, DataObjects.ColorDef> item in defaultColorizationSettings.DefaultLevelColorization)
				{
					if (!Enumerable.Contains(Colorization.creatureColorizationSettings.DefaultLevelColorization.Keys, item.Key))
					{
						Colorization.creatureColorizationSettings.DefaultLevelColorization.Add(item.Key, item.Value);
					}
				}
				if (Colorization.creatureColorizationSettings.CharacterColorGenerators != null)
				{
					Logger.LogInfo("Running color generators");
					DataObjects.CreatureColorizationSettings creatureColorizationSettings = Colorization.creatureColorizationSettings;
					if (creatureColorizationSettings.CharacterSpecificColorization == null)
					{
						Dictionary<string, Dictionary<int, DataObjects.ColorDef>> dictionary = (creatureColorizationSettings.CharacterSpecificColorization = new Dictionary<string, Dictionary<int, DataObjects.ColorDef>>());
					}
					foreach (KeyValuePair<string, List<DataObjects.ColorRangeDef>> characterColorGenerator in Colorization.creatureColorizationSettings.CharacterColorGenerators)
					{
						Logger.LogInfo("Building color range for " + characterColorGenerator.Key);
						foreach (DataObjects.ColorRangeDef item2 in characterColorGenerator.Value)
						{
							BuildAddColorRange(characterColorGenerator.Key, item2);
						}
					}
					if (ValConfig.OutputColorizationGeneratorsData.Value)
					{
						File.WriteAllText(Path.Combine(Paths.ConfigPath, "StarLevelSystem", "DebugGeneratedColorValues.yaml"), DataObjects.yamlSerializer.Serialize((object)Colorization.creatureColorizationSettings));
					}
				}
				Logger.LogInfo("Updated ColorizationSettings.");
				Character[] array = Resources.FindObjectsOfTypeAll<Character>();
				foreach (Character val in array)
				{
					if (val.m_level > 1)
					{
						DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(val);
						if (cacheEntry != null)
						{
							cacheEntry.Colorization = DetermineCharacterColorization(val, val.m_level);
							CompositeLazyCache.UpdateCharacterCacheEntry(val, cacheEntry);
							ApplyColorizationWithoutLevelEffects(((Component)val).gameObject, cacheEntry.Colorization);
						}
					}
				}
			}
			catch (Exception ex)
			{
				StarLevelSystem.Log.LogError((object)("Failed to parse ColorizationSettings YAML: " + ex.Message));
				StarLevelSystem.Log.LogError((object)"Colorization will use internal defaults.");
				Colorization.creatureColorizationSettings = defaultColorizationSettings;
				return false;
			}
			return true;
		}

		public static void ApplyLevelVisual(Character charc)
		{
			LevelEffects componentInChildren = ((Component)charc).gameObject.GetComponentInChildren<LevelEffects>();
			if (!((Object)(object)componentInChildren == (Object)null) && componentInChildren.m_levelSetups != null && componentInChildren.m_levelSetups.Count > 0)
			{
				LevelSetup val = componentInChildren.m_levelSetups[Random.Range(0, componentInChildren.m_levelSetups.Count - 1)];
				if ((Object)(object)val.m_enableObject != (Object)null)
				{
					val.m_enableObject.SetActive(true);
				}
			}
		}

		internal static DataObjects.ColorDef DetermineCharacterColorization(Character cgo, int level)
		{
			if ((Object)(object)cgo == (Object)null)
			{
				return null;
			}
			string prefabName = Utils.GetPrefabName(((Component)cgo).gameObject);
			if (creatureColorizationSettings.CharacterSpecificColorization != null && creatureColorizationSettings.CharacterSpecificColorization.ContainsKey(prefabName) && creatureColorizationSettings.CharacterSpecificColorization[prefabName].ContainsKey(level - 1) && creatureColorizationSettings.CharacterSpecificColorization[prefabName].TryGetValue(level - 1, out var value))
			{
				return value;
			}
			return GetDefaultColorization(level - 1);
		}

		internal static void ApplyColorizationWithoutLevelEffects(GameObject cgo, DataObjects.ColorDef colorization)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if (!ValConfig.EnableColorization.Value || colorization == null)
			{
				return;
			}
			LevelSetup val = colorization.ToLevelEffect();
			try
			{
				SkinnedMeshRenderer[] componentsInChildren = cgo.gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
				foreach (SkinnedMeshRenderer val2 in componentsInChildren)
				{
					Material[] sharedMaterials = ((Renderer)val2).sharedMaterials;
					if (sharedMaterials.Length != 0)
					{
						sharedMaterials[0] = new Material(sharedMaterials[0]);
						sharedMaterials[0].SetFloat("_Hue", val.m_hue);
						sharedMaterials[0].SetFloat("_Saturation", val.m_saturation);
						sharedMaterials[0].SetFloat("_Value", val.m_value);
						if (val.m_setEmissiveColor)
						{
							sharedMaterials[0].SetColor("_EmissionColor", val.m_emissiveColor);
						}
						((Renderer)val2).sharedMaterials = sharedMaterials;
					}
				}
			}
			catch (Exception arg)
			{
				Logger.LogError($"Exception while colorizing {arg}");
			}
		}

		internal static void BuildAddColorRange(string creatureKey, DataObjects.ColorRangeDef colorGen)
		{
			float num = Mathf.Abs(colorGen.EndColorDef.Hue) + Mathf.Abs(colorGen.StartColorDef.Hue);
			Mathf.Clamp(num, 0f, 2f);
			float num2 = Mathf.Abs(colorGen.EndColorDef.Saturation) + Mathf.Abs(colorGen.StartColorDef.Saturation);
			Mathf.Clamp(num2, 0f, 2f);
			float num3 = Mathf.Abs(colorGen.EndColorDef.Value) + Mathf.Abs(colorGen.StartColorDef.Value);
			Mathf.Clamp(num3, 0f, 2f);
			int num4 = colorGen.RangeEnd - colorGen.RangeStart;
			float num5 = num / (float)num4;
			float num6 = num2 / (float)num4;
			float num7 = num3 / (float)num4;
			int num8 = ((!(colorGen.StartColorDef.Hue > colorGen.EndColorDef.Hue)) ? 1 : (-1));
			int num9 = ((!(colorGen.StartColorDef.Saturation > colorGen.EndColorDef.Saturation)) ? 1 : (-1));
			int num10 = ((!(colorGen.StartColorDef.Value > colorGen.EndColorDef.Value)) ? 1 : (-1));
			if (colorGen.CharacterSpecific && !creatureColorizationSettings.CharacterSpecificColorization.ContainsKey(creatureKey))
			{
				creatureColorizationSettings.CharacterSpecificColorization.Add(creatureKey, new Dictionary<int, DataObjects.ColorDef>());
			}
			int num11 = colorGen.RangeStart;
			int num12 = 0;
			while (num11 < colorGen.RangeEnd + 1)
			{
				DataObjects.ColorDef value = new DataObjects.ColorDef
				{
					Hue = colorGen.StartColorDef.Hue + num5 * (float)num12 * (float)num8,
					Saturation = colorGen.StartColorDef.Saturation + num6 * (float)num12 * (float)num9,
					Value = colorGen.StartColorDef.Value + num7 * (float)num12 * (float)num10,
					IsEmissive = false
				};
				if (colorGen.CharacterSpecific)
				{
					if (!creatureColorizationSettings.CharacterSpecificColorization.ContainsKey(creatureKey))
					{
						creatureColorizationSettings.CharacterSpecificColorization.Add(creatureKey, new Dictionary<int, DataObjects.ColorDef>());
					}
					if (creatureColorizationSettings.CharacterSpecificColorization[creatureKey].ContainsKey(num11))
					{
						if (colorGen.OverwriteExisting)
						{
							creatureColorizationSettings.CharacterSpecificColorization[creatureKey][num11] = value;
						}
					}
					else
					{
						creatureColorizationSettings.CharacterSpecificColorization[creatureKey].Add(num11, value);
					}
				}
				else if (creatureColorizationSettings.DefaultLevelColorization.ContainsKey(num11))
				{
					if (colorGen.OverwriteExisting)
					{
						creatureColorizationSettings.DefaultLevelColorization[num11] = value;
					}
				}
				else
				{
					creatureColorizationSettings.DefaultLevelColorization.Add(num11, value);
				}
				num11++;
				num12++;
			}
		}

		internal static DataObjects.ColorDef GetDefaultColorization(int level)
		{
			if (creatureColorizationSettings.DefaultLevelColorization.ContainsKey(level))
			{
				return creatureColorizationSettings.DefaultLevelColorization[level];
			}
			return defaultColorization;
		}

		public static void UpdateMapColorSelection()
		{
			ParseColorOptions(ValConfig.DistanceRingColorOptions.Value, mapRingColors, "distance ring");
		}

		public static void UpdateZoneOverlayColorSelection()
		{
			ParseColorOptions(ValConfig.ZoneOverlayColorOptions.Value, zoneOverlayColors, "zone overlay");
		}

		private static void ParseColorOptions(string optionsCsv, List<Color> target, string contextLabel)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			target.Clear();
			Color item = default(Color);
			Color item2 = default(Color);
			foreach (string item3 in optionsCsv.Split(new char[1] { ',' }).ToList())
			{
				if (item3.StartsWith("#"))
				{
					if (ColorUtility.TryParseHtmlString(item3.Trim(), ref item))
					{
						target.Add(item);
						continue;
					}
					Logger.LogWarning("Unable to parse color string " + item3 + " for " + contextLabel + " colors. It will be skipped");
				}
				else
				{
					string key = StringExtensions.CapitalizeFirstLetter(item3.Trim());
					if (defaultColors.TryGetValue(key, out var value) && ColorUtility.TryParseHtmlString(value, ref item2))
					{
						target.Add(item2);
					}
				}
			}
		}
	}
	internal static class Compatibility
	{
		public static bool IsDropThatEnabled;

		public static bool IsExpandWorldEnabled;

		public static bool IsFGNEnabled;

		public static bool IsCustomRaidsEnabled;

		public static bool IsJewelcraftingEnabled;

		private static Type DropThatCharacterDropSessionManager;

		private static MethodInfo DropThatCharacterModifyDrop;

		private static MethodInfo JewelcraftingBossHudPostfix;

		public static bool CustomRaidsCompatActive
		{
			get
			{
				if (IsCustomRaidsEnabled)
				{
					return ValConfig.EnableCustomRaidsCompat.Value;
				}
				return false;
			}
		}

		public static bool DropThatCharacterModifyAvailable => DropThatCharacterModifyDrop != null;

		internal static void CheckModCompat()
		{
			try
			{
				Dictionary<string, BaseUnityPlugin> plugins = BepInExUtils.GetPlugins(false);
				if (plugins == null)
				{
					return;
				}
				if (Enumerable.Contains(plugins.Keys, "asharppen.valheim.drop_that"))
				{
					IsDropThatEnabled = true;
					DropThatCharacterDropSessionManager = Type.GetType("DropThat.Drop.CharacterDropSystem.Managers.CharacterDropSessionManager, DropThat");
					if (DropThatCharacterDropSessionManager != null)
					{
						DropThatCharacterModifyDrop = DropThatCharacterDropSessionManager.GetMethod("ModifyDrop", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
						{
							typeof(GameObject),
							typeof(List<KeyValuePair<GameObject, int>>),
							typeof(int)
						}, null);
					}
					if (!DropThatCharacterModifyAvailable)
					{
						Logger.LogWarning("Warning: DropThat compat method (CharacterDropSessionManager.ModifyDrop) not found; DropThat item modifiers will not be applied to creature loot.");
					}
				}
				if (Enumerable.Contains(plugins.Keys, "com.Fire.FiresGhettoNetworkMod"))
				{
					IsFGNEnabled = true;
				}
				if (Enumerable.Contains(plugins.Keys, "expand_world_size"))
				{
					IsExpandWorldEnabled = true;
				}
				if (Enumerable.Contains(plugins.Keys, "asharppen.valheim.custom_raids"))
				{
					IsCustomRaidsEnabled = true;
					Logger.LogInfo("Valheim.CustomRaids detected; CustomRaids raids will fire alongside SLS raids while EnableCustomRaidsCompat is enabled.");
				}
				if (Enumerable.Contains(plugins.Keys, "org.bepinex.plugins.jewelcrafting"))
				{
					IsJewelcraftingEnabled = true;
					JewelcraftingBossHudPostfix = AccessTools.Method("Jewelcrafting.WorldBosses.BossHud+DisplayMultipleBossHuds:Postfix", (Type[])null, (Type[])null);
					if (JewelcraftingBossHudPostfix == null)
					{
						Logger.LogWarning("Jewelcrafting detected but DisplayMultipleBossHuds.Postfix could not be found; boss-HUD compatibility patch will be skipped.");
					}
				}
			}
			catch
			{
				Logger.LogWarning("Unable to check mod compatibility. Ensure that Bepinex can load.");
			}
		}

		public static void DropThat_ModifyCharacterDrop(GameObject drop, List<KeyValuePair<GameObject, int>> drops, int index)
		{
			if (!DropThatCharacterModifyAvailable)
			{
				return;
			}
			try
			{
				DropThatCharacterModifyDrop.Invoke(null, new object[3] { drop, drops, index });
			}
			catch (Exception ex)
			{
				Logger.LogWarning("DropThat ModifyDrop failed: " + ex.Message);
			}
		}

		internal static void ApplyConditionalPatches(Harmony harmony)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			if (IsJewelcraftingEnabled && JewelcraftingBossHudPostfix != null)
			{
				harmony.Patch((MethodBase)JewelcraftingBossHudPostfix, new HarmonyMethod(AccessTools.Method(typeof(Compatibility), "SkipJewelcraftingBossHud", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Logger.LogInfo("Jewelcrafting detected; suppressing its multi-boss HUD layout so SLS controls the boss healthbars.");
			}
		}

		private static bool SkipJewelcraftingBossHud()
		{
			return !ValConfig.EnableJewelCraftingBossHudCompat.Value;
		}
	}
	public static class MultiplayerDamageMod
	{
		[HarmonyPatch(typeof(Game), "GetDifficultyDamageScalePlayer")]
		public static class PatchPerPlayerDamageScaling
		{
			public static bool Prefix(Game __instance, Vector3 pos, ref float __result)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				if (!ValConfig.EnableMultiplayerEnemyDamageScaling.Value)
				{
					__result = 1f;
					return false;
				}
				int playerDifficulty = __instance.GetPlayerDifficulty(pos);
				if (playerDifficulty >= ValConfig.MultiplayerScalingRequiredPlayersNearby.Value)
				{
					float num = (1f + (float)playerDifficulty) * ValConfig.MultiplayerEnemyDamageModifier.Value;
					__result = 1f + num;
				}
				else
				{
					__result = 1f;
				}
				return false;
			}
		}
	}
	public static class MultiplayerHealthMod
	{
		[HarmonyPatch(typeof(Game), "GetDifficultyDamageScaleEnemy")]
		public static class PatchPerPlayerDamageScaling
		{
			public static bool Prefix(Game __instance, Vector3 pos, ref float __result)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				if (!ValConfig.EnableMultiplayerEnemyHealthScaling.Value)
				{
					__result = 1f;
					return false;
				}
				int playerDifficulty = __instance.GetPlayerDifficulty(pos);
				if (playerDifficulty >= ValConfig.MultiplayerScalingRequiredPlayersNearby.Value)
				{
					__result = Mathf.Max(1f - (float)playerDifficulty * ValConfig.MultiplayerEnemyHealthModifier.Value, ValConfig.MultiplayerEnemyMinDamageTaken.Value);
				}
				else
				{
					__result = 1f;
				}
				return false;
			}
		}
	}
	internal class SpawnLevelExtension
	{
		[HarmonyPatch]
		internal static class SpawnCommandDelegate
		{
			[HarmonyTargetMethod]
			internal static MethodBase FindSpawnCommandDelegateMethod()
			{
				return (from method in AccessTools.GetDeclaredMethods(typeof(Terminal))
					where method.Name.IndexOf("__spawn|", StringComparison.Ordinal) >= 0
					select method).FirstOrDefault();
			}

			[HarmonyTranspiler]
			internal static IEnumerable<CodeInstruction> SpawnCommandDelegateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Expected O, but got Unknown
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Expected O, but got Unknown
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Expected O, but got Unknown
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Expected O, but got Unknown
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Expected O, but got Unknown
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Expected O, but got Unknown
				//IL_0199: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Expected O, but got Unknown
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Expected O, but got Unknown
				//IL_0200: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Expected O, but got Unknown
				//IL_0229: Unknown result type (might be due to invalid IL or missing references)
				//IL_022f: Expected O, but got Unknown
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0243: Expected O, but got Unknown
				//IL_0251: Unknown result type (might be due to invalid IL or missing references)
				//IL_0257: Expected O, but got Unknown
				//IL_026c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0276: Expected O, but got Unknown
				//IL_027c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0286: Expected O, but got Unknown
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0296: Expected O, but got Unknown
				Type[] array = new Type[2]
				{
					typeof(int),
					typeof(int)
				};
				return new CodeMatcher(instructions, generator).Start().MatchStartForward((CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(ItemDrop), "OnCreateNew", new Type[1] { typeof(GameObject) }, (Type[])null), (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null)
				}).ThrowIfInvalid("Could not patch Terminal.SpawnCommandDelegate()! (level-compare)")
					.Advance(3)
					.RemoveInstruction()
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldc_I4_0, (object)null)
					})
					.MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
					{
						new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Mathf), "Min", array, (Type[])null), (string)null)
					})
					.ThrowIfInvalid("Could not patch Terminal.SpawnCommandDelegate()! (mathf-min-4)")
					.SetInstructionAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SpawnCommandDelegate), "MathfMinDelegate", (Type[])null, (Type[])null)))
					.MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
					{
						new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Mathf), "Min", array, (Type[])null), (string)null)
					})
					.ThrowIfInvalid("Could not patch Terminal.SpawnCommandDelegate()! (mathf-min-9)")
					.SetInstructionAndAdvance(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SpawnCommandDelegate), "MathfMinDelegate", (Type[])null, (Type[])null)))
					.MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
					{
						new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Character), "SetLevel", (Type[])null, (Type[])null), (string)null)
					})
					.RemoveInstructions(1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SpawnCommandDelegate), "SetCreatureSpawnLevel", (Type[])null, (Type[])null))
					})
					.ThrowIfInvalid("Could not patch terminal.SpawnCommandDelegate()! (SetCreatureSpawnLevel)")
					.MatchStartForward((CodeMatch[])(object)new CodeMatch[3]
					{
						new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldc_I4_4, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Stfld, (object)null, (string)null)
					})
					.ThrowIfInvalid("Could not patch Terminal.SpawnCommandDelegate()! (set-level-4)")
					.SetInstructionAndAdvance(new CodeInstruction(OpCodes.Nop, (object)null))
					.SetInstructionAndAdvance(new CodeInstruction(OpCodes.Nop, (object)null))
					.SetInstructionAndAdvance(new CodeInstruction(OpCodes.Nop, (object)null))
					.InstructionEnumeration();
			}

			private static int MathfMinDelegate(int level, int value)
			{
				return level;
			}

			private static void SetCreatureSpawnLevel(Character chara, int level)
			{
				CompositeLazyCache.GetAndSetLocalCache(chara, level, null, null, updateCache: true);
				chara.m_nview.GetZDO().Set(ZDOVars.s_level, level, false);
				CreatureSetupControl.CreatureSetup(chara, level, multiply: false, 0.01f);
			}
		}
	}
	internal class Spawnrate
	{
		internal static bool CheckSetApplySpawnrate(Character chara, DataObjects.CharacterCacheEntry ccEntry)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			if (ValConfig.BossCreaturesNeverSpawnMultiply.Value && chara.IsBoss())
			{
				return false;
			}
			bool flag = chara.IsTamed();
			if (flag && ValConfig.SpawnMultiplicationAppliesToTames.Value)
			{
				return false;
			}
			if (chara.m_nview.GetZDO().GetBool(DataObjects.SLS_SPAWN_MULT, false))
			{
				return false;
			}
			chara.m_nview.GetZDO().Set(DataObjects.SLS_SPAWN_MULT, true);
			float spawnRateModifier = ccEntry.SpawnRateModifier;
			if (ValConfig.EnableNemesisSystem.Value && !flag)
			{
				NemesisActions.NemesisRandomSpawner(chara);
			}
			if (spawnRateModifier > 1f)
			{
				for (spawnRateModifier -= 1f; spawnRateModifier > 0f; spawnRateModifier -= 1f)
				{
					if (Random.value <= spawnRateModifier)
					{
						Vector3 val = ((Component)chara).transform.position;
						if (((Component)chara).transform.position.y < 3000f)
						{
							val = DetermineOffsetPosition(val, 15f);
						}
						Quaternion val2 = Quaternion.Euler(0f, Random.Range(0f, 360f), 0f);
						GameObject val3 = Object.Instantiate<GameObject>(PrefabManager.Instance.GetPrefab(ccEntry.RefCreatureName), val, val2);
						Character component = val3.GetComponent<Character>();
						if (flag && (Object)(object)component != (Object)null)
						{
							component.SetTamed(true);
						}
						Logger.LogDebug($"Spawn Multiplier| {spawnRateModifier} Spawned {val3.gameObject} at {val}");
						CreatureSetupControl.CreatureSetup(component, 0, multiply: false);
						component.m_nview.GetZDO().Set(DataObjects.SLS_SPAWN_MULT, true);
						if (ValConfig.MultipliedNightSpawnsRemovedDuringDay.Value && EnvMan.IsNight())
						{
							MonsterAI component2 = ((Component)component).GetComponent<MonsterAI>();
							if ((Object)(object)component2 != (Object)null)
							{
								component2.SetDespawnInDay(true);
							}
						}
					}
				}
			}
			else if (spawnRateModifier < 1f && Random.value >= spawnRateModifier)
			{
				Logger.LogDebug("Spawn Reducer| Selecting " + ccEntry.RefCreatureName + " for deletion.");
				ZNetScene.instance.Destroy(((Component)chara).gameObject);
				return true;
			}
			return false;
		}

		internal static IEnumerator DestroyCoroutine(GameObject go)
		{
			yield return (object)new WaitForEndOfFrame();
			if (!((Object)(object)go != (Object)null))
			{
				yield break;
			}
			Character component = go.GetComponent<Character>();
			if (!((Object)(object)component != (Object)null) || !component.m_tamed)
			{
				CharacterDrop component2 = go.GetComponent<CharacterDrop>();
				if ((Object)(object)component2 != (Object)null)
				{
					Object.Destroy((Object)(object)component2);
				}
				ZNetScene.instance.Destroy(go);
			}
		}

		internal static Vector3 DetermineOffsetPosition(Vector3 sourcePosition, float radius)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			float num = default(float);
			ZoneSystem.instance.GetGroundHeight(sourcePosition, ref num);
			float num2 = 0f;
			if (num > sourcePosition.y + 2f)
			{
				num2 = Mathf.Abs(sourcePosition.y - num);
				if (num2 < 0f)
				{
					num2 = 0f;
				}
			}
			int num3 = 0;
			if (num3 < 10)
			{
				Vector2 val = Random.insideUnitCircle * (radius * 0.8f);
				Vector3 val2 = sourcePosition + new Vector3(val.x, 0f, val.y);
				num3++;
				float num4 = default(float);
				ZoneSystem.instance.GetGroundHeight(new Vector3(val2.x, val2.y + 100f, val2.z), ref num4);
				val2.y = num4 + num2;
				return val2;
			}
			return sourcePosition;
		}
	}
	internal static class TaskRunner
	{
		internal static GameObject RunnerGO;

		internal static Orchestrator Instance;

		internal static void Setup()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0020: Expected O, but got Unknown
			GameObject val = new GameObject("StarLevelSystem_TaskRunner");
			Instance = val.AddComponent<Orchestrator>();
			RunnerGO = val;
			Object.DontDestroyOnLoad((Object)val);
		}

		internal static Orchestrator Run()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				return Instance;
			}
			Setup();
			return Instance;
		}
	}
	internal class Orchestrator : MonoBehaviour
	{
	}
}
namespace StarLevelSystem.modules.UI
{
	internal static class MinimapLevelIndicator
	{
		[HarmonyPatch(typeof(Minimap), "Awake")]
		public static class CreateIndicator
		{
			public static void Postfix(Minimap __instance)
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_mapImageSmall == (Object)null || (Object)(object)indicatorText != (Object)null)
				{
					return;
				}
				try
				{
					Transform transform = ((Component)__instance.m_mapImageSmall).transform;
					indicatorText = GUIManager.Instance.CreateText("", transform, new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(-8f, 8f), GUIManager.Instance.AveriaSerifBold, 14, GUIManager.Instance.ValheimYellow, true, Color.black, 200f, 44f, false).GetComponent<Text>();
					((Graphic)indicatorText).rectTransform.pivot = new Vector2(1f, 0f);
					((Graphic)indicatorText).rectTransform.anchoredPosition = new Vector2(-8f, 8f);
					indicatorText.alignment = (TextAnchor)8;
					((Component)indicatorText).gameObject.SetActive(false);
				}
				catch (Exception ex)
				{
					Logger.LogWarning("Failed to create minimap level indicator: " + ex.Message);
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "Update")]
		public static class RefreshIndicator
		{
			public static void Postfix()
			{
				MinimapOverlayFog.MaybeRefreshForExploration();
				if (!((Object)(object)indicatorText == (Object)null) && !(Time.time < nextRefresh))
				{
					nextRefresh = Time.time + 5f;
					Refresh();
				}
			}
		}

		private static Text indicatorText;

		private static float nextRefresh;

		private const float RefreshInterval = 5f;

		private static void Refresh()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!ValConfig.ShowMinimapLevelIndicator.Value || (Object)(object)localPlayer == (Object)null)
			{
				if (((Component)indicatorText).gameObject.activeSelf)
				{
					((Component)indicatorText).gameObject.SetActive(false);
				}
				return;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			List<string> list = new List<string>(2);
			if (ValConfig.EnableDistanceLevelScalingBonus.Value)
			{
				list.Add($"Ring {DistanceScaleSystem.GetCurrentRingLevel(position)}");
			}
			if (ValConfig.EnableZoneScalingBonus.Value)
			{
				list.Add($"Zone {ZoneScaleSystemData.GetZoneForPosition(position)?.ZoneLevel ?? 0}");
			}
			if (list.Count == 0)
			{
				if (((Component)indicatorText).gameObject.activeSelf)
				{
					((Component)indicatorText).gameObject.SetActive(false);
				}
				return;
			}
			indicatorText.text = string.Join("\n", list);
			if (!((Component)indicatorText).gameObject.activeSelf)
			{
				((Component)indicatorText).gameObject.SetActive(true);
			}
		}

		public static void OnShowIndicatorChanged(object s, EventArgs e)
		{
			if (!((Object)(object)indicatorText == (Object)null))
			{
				if (!ValConfig.ShowMinimapLevelIndicator.Value)
				{
					((Component)indicatorText).gameObject.SetActive(false);
				}
				else
				{
					nextRefresh = 0f;
				}
			}
		}
	}
	internal static class QuickConfigureTool
	{
		private class StagedConfig
		{
			public bool enableDistance;

			public bool enableDistanceOverlay;

			public bool enableZone;

			public bool enableZoneOverlay;

			public bool enableConditional;

			public float creatureHpPerLevel;

			public float creatureDmgPerLevel;

			public float bossHpPerLevel;

			public float bossDmgPerLevel;

			public int maxLevel;

			public int maxBossLevel;

			public bool mpHealth;

			public bool mpDamage;

			public float mpHealthMod;

			public float mpDamageMod;

			public int mpRequiredPlayers;

			public DataObjects.LevelGenerator generator;

			public int maxMajor;

			public int maxMinor;

			public int maxBossMods;

			public int prefixLimit;

			public float chanceMajor;

			public float chanceMinor;

			public float chanceBoss;

			public bool limitToStarLevel;

			public bool enableBossMods;

			public bool minorFirst;

			public DataObjects.ModifierDisplayStyle displayStyle;

			public DataObjects.CreatureModifierCollection modifierSource;

			public Dictionary<DataObjects.ModifierType, HashSet<string>> modifierOn;

			public bool enableSlsRaids;

			public float raidEventRate;

			public int raidCheckMinutes;

			public int maxRaidAttempts;

			public int maxActiveRaids;

			public DataObjects.RaidConfiguration raidSource;

			public HashSet<string> raidsOn;

			public bool enableNemesis;

			public float nemCooldown;

			public float nemInfluence;

			public float nemMinSpawn;

			public float neutralScore;

			public float minScore;

			public float maxScore;

			public float decayPerUpdate;

			public float scoreInterval;

			public float bossKillBonus;

			public float deathReduction;

			public DataObjects.NemesisConfiguration nemesisSource;

			public static StagedConfig Snapshot()
			{
				StagedConfig stagedConfig = new StagedConfig
				{
					enableDistance = ValConfig.EnableDistanceLevelScalingBonus.Value,
					enableDistanceOverlay = ValConfig.EnableMapRingsForDistanceBonus.Value,
					enableZone = ValConfig.EnableZoneScalingBonus.Value,
					enableZoneOverlay = ValConfig.EnableZoneMapOverlay.Value,
					creatureHpPerLevel = ValConfig.EnemyHealthMultiplier.Value,
					creatureDmgPerLevel = ValConfig.EnemyDamageLevelMultiplier.Value,
					bossHpPerLevel = ValConfig.BossEnemyHealthMultiplier.Value,
					bossDmgPerLevel = ValConfig.BossEnemyDamageMultiplier.Value,
					maxLevel = ValConfig.MaxLevel.Value,
					maxBossLevel = ValConfig.MaxBossLevel.Value,
					mpHealth = ValConfig.EnableMultiplayerEnemyHealthScaling.Value,
					mpHealthMod = ValConfig.MultiplayerEnemyHealthModifier.Value,
					mpDamage = ValConfig.EnableMultiplayerEnemyDamageScaling.Value,
					mpDamageMod = ValConfig.MultiplayerEnemyDamageModifier.Value,
					mpRequiredPlayers = ValConfig.MultiplayerScalingRequiredPlayersNearby.Value,
					maxMajor = ValConfig.MaxMajorModifiersPerCreature.Value,
					maxMinor = ValConfig.MaxMinorModifiersPerCreature.Value,
					chanceMajor = ValConfig.ChanceMajorModifier.Value,
					chanceMinor = ValConfig.ChanceMinorModifier.Value,
					limitToStarLevel = ValConfig.LimitCreatureModifiersToCreatureStarLevel.Value,
					enableBossMods = ValConfig.EnableBossModifiers.Value,
					chanceBoss = ValConfig.ChanceOfBossModifier.Value,
					maxBossMods = ValConfig.MaxBossModifiersPerBoss.Value,
					prefixLimit = ValConfig.LimitCreatureModifierPrefixes.Value,
					minorFirst = ValConfig.MinorModifiersFirstInName.Value,
					enableSlsRaids = !ValConfig.UseVanillaRaidConfiguration.Value,
					raidEventRate = ValConfig.RaidEventRate.Value,
					raidCheckMinutes = ValConfig.ServerTimeBetweenRaidStartChecks.Value,
					maxRaidAttempts = ValConfig.MaxRaidAttemptsPerPlayer.Value,
					maxActiveRaids = ValConfig.MaxActiveRaids.Value,
					enableNemesis = ValConfig.EnableNemesisSystem.Value
				};
				DataObjects.CreatureLevelSettings sLE_Level_Settings = LevelSystemData.SLE_Level_Settings;
				stagedConfig.enableConditional = sLE_Level_Settings?.EnableConditionalCreatureLevelupChance ?? false;
				stagedConfig.generator = CloneOrDefaultGenerator(sLE_Level_Settings, stagedConfig.maxLevel);
				if (!Enum.TryParse<DataObjects.ModifierDisplayStyle>(ValConfig.ModifierIconDisplayStyle.Value, out var result))
				{
					result = DataObjects.ModifierDisplayStyle.Stars;
				}
				stagedConfig.displayStyle = result;
				stagedConfig.modifierSource = CreatureModifiersData.ActiveCreatureModifiers;
				stagedConfig.modifierOn = new Dictionary<DataObjects.ModifierType, HashSet<string>>
				{
					{
						DataObjects.ModifierType.Boss,
						KeysOf(stagedConfig.modifierSource?.BossModifiers)
					},
					{
						DataObjects.ModifierType.Major,
						KeysOf(stagedConfig.modifierSource?.MajorModifiers)
					},
					{
						DataObjects.ModifierType.Minor,
						KeysOf(stagedConfig.modifierSource?.MinorModifiers)
					}
				};
				DataObjects.NemesisConfiguration nemesisConfiguration = (stagedConfig.nemesisSource = NemesisSystemData.SLE_Nemesis_Settings);
				if (nemesisConfiguration != null)
				{
					stagedConfig.nemCooldown = nemesisConfiguration.NemesisActionCooldownSeconds;
					stagedConfig.nemInfluence = nemesisConfiguration.NemesisInfluenceRadius;
					stagedConfig.nemMinSpawn = nemesisConfiguration.NemesisMinSpawnDistance;
					DataObjects.NemesisScore nemesisScore = nemesisConfiguration.ScoreSystem ?? new DataObjects.NemesisScore();
					stagedConfig.neutralScore = nemesisScore.NeutralScore;
					stagedConfig.minScore = nemesisScore.MinScore;
					stagedConfig.maxScore = nemesisScore.MaxScore;
					stagedConfig.decayPerUpdate = nemesisScore.DecayPerUpdate;
					stagedConfig.scoreInterval = nemesisScore.ScoreIntervalSeconds;
					stagedConfig.bossKillBonus = nemesisScore.BossKillBonus;
					stagedConfig.deathReduction = nemesisScore.DeathScoreReduction;
				}
				stagedConfig.raidSource = RaidsData.SLE_Raid_Settings;
				stagedConfig.raidsOn = new HashSet<string>();
				if (stagedConfig.raidSource?.Raids != null)
				{
					foreach (DataObjects.RaidDefinition raid in stagedConfig.raidSource.Raids)
					{
						if (raid.Enabled)
						{
							stagedConfig.raidsOn.Add(raid.Name);
						}
					}
				}
				return stagedConfig;
			}

			private static HashSet<string> KeysOf(Dictionary<string, DataObjects.CreatureModifierConfiguration> dict)
			{
				HashSet<string> hashSet = new HashSet<string>();
				if (dict == null)
				{
					return hashSet;
				}
				foreach (KeyValuePair<string, DataObjects.CreatureModifierConfiguration> item in dict)
				{
					if (item.Value.Enabled)
					{
						hashSet.Add(item.Key);
					}
				}
				return hashSet;
			}

			private static DataObjects.LevelGenerator CloneOrDefaultGenerator(DataObjects.CreatureLevelSettings settings, int maxLevel)
			{
				DataObjects.LevelGenerator levelGenerator = null;
				if (settings?.DefaultLevelupGenerators != null && settings.DefaultLevelupGenerators.Count > 0)
				{
					levelGenerator = settings.DefaultLevelupGenerators[0];
				}
				if (levelGenerator == null)
				{
					return new DataObjects.LevelGenerator
					{
						MinLevel = 1,
						MaxLevel = Mathf.Max(1, maxLevel),
						LevelUpChance = 0.2f,
						LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential,
						GaussianOffset = 0f,
						NightMultiplier = 1f
					};
				}
				return new DataObjects.LevelGenerator
				{
					PrefabName = levelGenerator.PrefabName,
					MinLevel = levelGenerator.MinLevel,
					MaxLevel = levelGenerator.MaxLevel,
					LevelUpChance = levelGenerator.LevelUpChance,
					LevelupCalculationStyle = levelGenerator.LevelupCalculationStyle,
					GaussianOffset = levelGenerator.GaussianOffset,
					NightMultiplier = levelGenerator.NightMultiplier
				};
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__38_0;

			public static UnityAction <>9__38_1;

			public static Action<bool> <>9__40_0;

			public static Action<bool> <>9__40_1;

			public static Action<bool> <>9__40_2;

			public static Action<bool> <>9__40_3;

			public static Action<bool> <>9__40_4;

			public static Action<float> <>9__41_3;

			public static Action<float> <>9__41_4;

			public static Action<float> <>9__41_5;

			public static Action<float> <>9__41_6;

			public static Action<float> <>9__41_7;

			public static Action<float> <>9__41_8;

			public static Action<bool> <>9__41_9;

			public static Action<float> <>9__41_10;

			public static Action<bool> <>9__41_11;

			public static Action<float> <>9__41_12;

			public static Action<float> <>9__41_13;

			public static Action<float> <>9__41_14;

			public static Action<float> <>9__41_15;

			public static Action<float> <>9__41_16;

			public static Action<float> <>9__41_1;

			public static Action<float> <>9__41_2;

			public static Action<bool> <>9__42_0;

			public static Action<float> <>9__42_1;

			public static Action<float> <>9__42_2;

			public static Action<float> <>9__42_3;

			public static Action<float> <>9__42_4;

			public static Func<DataObjects.RaidDefinition, string> <>9__42_5;

			public static Func<DataObjects.RaidSpawnEntry, string> <>9__43_1;

			public static Action<bool> <>9__45_0;

			public static Action<float> <>9__45_1;

			public static Action<float> <>9__45_2;

			public static Action<float> <>9__45_3;

			public static Action<float> <>9__45_4;

			public static Action<float> <>9__45_5;

			public static Action<float> <>9__45_6;

			public static Action<float> <>9__45_7;

			public static Action<float> <>9__45_8;

			public static Action<float> <>9__45_9;

			public static Action<float> <>9__45_10;

			public static Action<float> <>9__46_0;

			public static Action<float> <>9__46_1;

			public static Action<float> <>9__46_2;

			public static Action<float> <>9__46_3;

			public static Action<bool> <>9__46_4;

			public static Action<bool> <>9__46_5;

			public static Action<float> <>9__46_6;

			public static Action<float> <>9__46_7;

			public static Action<float> <>9__46_8;

			public static Action<bool> <>9__46_9;

			public static Action<int> <>9__46_10;

			public static Func<string, string> <>9__47_0;

			internal void <BuildPanel>b__38_0()
			{
				ShowPage(currentPage - 1);
			}

			internal void <BuildPanel>b__38_1()
			{
				ShowPage(currentPage + 1);
			}

			internal void <BuildScalingPage>b__40_0(bool v)
			{
				staged.enableDistance = v;
			}

			internal void <BuildScalingPage>b__40_1(bool v)
			{
				staged.enableDistanceOverlay = v;
			}

			internal void <BuildScalingPage>b__40_2(bool v)
			{
				staged.enableZone = v;
			}

			internal void <BuildScalingPage>b__40_3(bool v)
			{
				staged.enableZoneOverlay = v;
			}

			internal void <BuildScalingPage>b__40_4(bool v)
			{
				staged.enableConditional = v;
			}

			internal void <BuildStatsPage>b__41_3(float v)
			{
				staged.creatureHpPerLevel = v;
				UpdateExampleMath();
			}

			internal void <BuildStatsPage>b__41_4(float v)
			{
				staged.creatureDmgPerLevel = v;
				UpdateExampleMath();
			}

			internal void <BuildStatsPage>b__41_5(float v)
			{
				staged.maxLevel = (int)v;
				UpdateExampleMath();
			}

			internal void <BuildStatsPage>b__41_6(float v)
			{
				staged.bossHpPerLevel = v;
				UpdateExampleMath();
			}

			internal void <BuildStatsPage>b__41_7(float v)
			{
				staged.bossDmgPerLevel = v;
				UpdateExampleMath();
			}

			internal void <BuildStatsPage>b__41_8(float v)
			{
				staged.maxBossLevel = (int)v;
				UpdateExampleMath();
			}

			internal void <BuildStatsPage>b__41_9(bool v)
			{
				staged.mpHealth = v;
			}

			internal void <BuildStatsPage>b__41_10(float v)
			{
				staged.mpHealthMod = v;
			}

			internal void <BuildStatsPage>b__41_11(bool v)
			{
				staged.mpDamage = v;
			}

			internal void <BuildStatsPage>b__41_12(float v)
			{
				staged.mpDamageMod = v;
			}

			internal void <BuildStatsPage>b__41_13(float v)
			{
				staged.mpRequiredPlayers = (int)v;
			}

			internal void <BuildStatsPage>b__41_14(float v)
			{
				staged.generator.MinLevel = (int)v;
			}

			internal void <BuildStatsPage>b__41_15(float v)
			{
				staged.generator.MaxLevel = (int)v;
			}

			internal void <BuildStatsPage>b__41_16(float v)
			{
				staged.generator.LevelUpChance = v;
			}

			internal void <BuildStatsPage>b__41_1(float v)
			{
				staged.generator.GaussianOffset = v;
			}

			internal void <BuildStatsPage>b__41_2(float v)
			{
				staged.generator.NightMultiplier = v;
			}

			internal void <BuildRaidsPage>b__42_0(bool v)
			{
				staged.enableSlsRaids = v;
			}

			internal void <BuildRaidsPage>b__42_1(float v)
			{
				staged.raidEventRate = v;
			}

			internal void <BuildRaidsPage>b__42_2(float v)
			{
				staged.raidCheckMinutes = (int)v;
			}

			internal void <BuildRaidsPage>b__42_3(float v)
			{
				staged.maxRaidAttempts = (int)v;
			}

			internal void <BuildRaidsPage>b__42_4(float v)
			{
				staged.maxActiveRaids = (int)v;
			}

			internal string <BuildRaidsPage>b__42_5(DataObjects.RaidDefinition r)
			{
				return r.Name;
			}

			internal string <AddRaidEntry>b__43_1(DataObjects.RaidSpawnEntry sp)
			{
				return sp.PrefabName;
			}

			internal void <BuildNemesisPage>b__45_0(bool v)
			{
				staged.enableNemesis = v;
			}

			internal void <BuildNemesisPage>b__45_1(float v)
			{
				staged.nemCooldown = v;
			}

			internal void <BuildNemesisPage>b__45_2(float v)
			{
				staged.nemInfluence = v;
			}

			internal void <BuildNemesisPage>b__45_3(float v)
			{
				staged.nemMinSpawn = v;
			}

			internal void <BuildNemesisPage>b__45_4(float v)
			{
				staged.neutralScore = v;
			}

			internal void <BuildNemesisPage>b__45_5(float v)
			{
				staged.minScore = v;
			}

			internal void <BuildNemesisPage>b__45_6(float v)
			{
				staged.maxScore = v;
			}

			internal void <BuildNemesisPage>b__45_7(float v)
			{
				staged.decayPerUpdate = v;
			}

			internal void <BuildNemesisPage>b__45_8(float v)
			{
				staged.scoreInterval = v;
			}

			internal void <BuildNemesisPage>b__45_9(float v)
			{
				staged.bossKillBonus = v;
			}

			internal void <BuildNemesisPage>b__45_10(float v)
			{
				staged.deathReduction = v;
			}

			internal void <BuildModifiersPage>b__46_0(float v)
			{
				staged.maxMajor = (int)v;
			}

			internal void <BuildModifiersPage>b__46_1(float v)
			{
				staged.maxMinor = (int)v;
			}

			internal void <BuildModifiersPage>b__46_2(float v)
			{
				staged.chanceMajor = v;
			}

			internal void <BuildModifiersPage>b__46_3(float v)
			{
				staged.chanceMinor = v;
			}

			internal void <BuildModifiersPage>b__46_4(bool v)
			{
				staged.limitToStarLevel = v;
			}

			internal void <BuildModifiersPage>b__46_5(bool v)
			{
				staged.enableBossMods = v;
			}

			internal void <BuildModifiersPage>b__46_6(float v)
			{
				staged.chanceBoss = v;
			}

			internal void <BuildModifiersPage>b__46_7(float v)
			{
				staged.maxBossMods = (int)v;
			}

			internal void <BuildModifiersPage>b__46_8(float v)
			{
				staged.prefixLimit = (int)v;
			}

			internal void <BuildModifiersPage>b__46_9(bool v)
			{
				staged.minorFirst = v;
			}

			internal void <BuildModifiersPage>b__46_10(int i)
			{
				staged.displayStyle = (DataObjects.ModifierDisplayStyle)i;
			}

			internal string <AddModifierCategory>b__47_0(string n)
			{
				return n;
			}
		}

		private const float PanelW = 900f;

		private const float PanelH = 690f;

		private const float Margin = 26f;

		private const float ContentTop = 92f;

		private const float RowHeight = 34f;

		private const float SubRowHeight = 26f;

		private const float RowGap = 4f;

		private const int PageCount = 5;

		private const float TrollHp = 600f;

		private const float TrollDmg = 70f;

		private const float TheElderHP = 2500f;

		private const float TheElderDmg = 60f;

		private static readonly string[] CalcStyleOptions = Enum.GetNames(typeof(DataObjects.LevelupCalculationStyle));

		private static readonly string[] DisplayStyleOptions = Enum.GetNames(typeof(DataObjects.ModifierDisplayStyle));

		private static readonly Dictionary<string, string> ModifierDescriptions = new Dictionary<string, string>
		{
			{ "BossSummoner", "Summons minion creatures at regular intervals." },
			{ "SoulEater", "Grows stronger as nearby creatures die; self-heals." },
			{ "LifeLink", "Redirects some damage taken to a nearby creature." },
			{ "Splitter", "Spawns replacement creatures when it dies." },
			{ "Lootbags", "Tankier and faster; drops extra loot." },
			{ "Fire", "Adds fire damage to its attacks." },
			{ "Frost", "Adds frost damage to its attacks." },
			{ "Poison", "Adds poison damage to its attacks." },
			{ "Lightning", "Adds lightning damage to its attacks." },
			{ "FireNova", "Explodes in fire on death, damaging nearby targets." },
			{ "FrostNova", "Explodes in frost on death, damaging nearby targets." },
			{ "PoisonNova", "Explodes in poison on death, damaging nearby targets." },
			{ "LightningNova", "Explodes in lightning on death, damaging nearby targets." },
			{ "Evolving", "Gains a level after enough kills." },
			{ "ResistSlash", "Reduces damage taken from slash." },
			{ "ResistBlunt", "Reduces damage taken from blunt." },
			{ "ResistPierce", "Reduces damage taken from pierce (e.g. arrows)." },
			{ "ResistFire", "Reduces damage taken from fire." },
			{ "ResistFrost", "Reduces damage taken from frost." },
			{ "ResistPoison", "Reduces damage taken from poison." },
			{ "ResistSpirit", "Reduces damage taken from spirit." },
			{ "Alert", "Increases the creature's hearing range." },
			{ "Big", "Increases the creature's size." },
			{ "Fast", "Increases the creature's movement speed." },
			{ "StaminaDrain", "Its attacks drain your stamina. Dodging avoids it; blocking or parrying lessens it." },
			{ "EitrDrain", "Its attacks drain your eitr. Dodging avoids it; blocking or parrying lessens it." },
			{ "Brutal", "Increases the creature's attack speed." },
			{ "ElementalChaos", "Adds random elemental damage on each hit." }
		};

		private static Sprite DistanceExample;

		private static Sprite ZoneExample;

		private static GameObject panel;

		private static GameObject[] pageRoots;

		private static int currentPage;

		private static Text titleText;

		private static GameObject backBtn;

		private static GameObject cancelBtn;

		private static GameObject nextBtn;

		private static GameObject applyBtn;

		private static Text creatureExampleText;

		private static Text bossExampleText;

		private static StagedConfig staged;

		private static GameObject mainMenuButton;

		private static GameObject pauseMenuButton;

		internal static void Init()
		{
			GUIManager.OnCustomGUIAvailable += OnCustomGUIAvailable;
			DistanceExample = StarLevelSystem.EmbeddedResourceBundle.LoadAsset<Sprite>("distance_rings");
			ZoneExample = StarLevelSystem.EmbeddedResourceBundle.LoadAsset<Sprite>("region_zones");
		}

		private static void OnCustomGUIAvailable()
		{
			try
			{
				if (!GUIManager.IsHeadless() && GUIManager.Instance != null && (Object)(object)FejdStartup.instance != (Object)null)
				{
					CreateMainMenuButton();
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning("QuickConfigureTool failed to set up main menu button: " + ex.Message);
			}
		}

		internal static void CreatePauseMenuButton(Menu menu)
		{
			try
			{
				if (!GUIManager.IsHeadless() && GUIManager.Instance != null && !((Object)(object)menu == (Object)null) && !((Object)(object)menu.m_root == (Object)null) && !((Object)(object)pauseMenuButton != (Object)null))
				{
					pauseMenuButton = CreateCornerButton(menu.m_root);
					pauseMenuButton.SetActive(ValConfig.ShowQuickConfigureButton.Value && SynchronizationManager.Instance.PlayerIsAdmin);
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning("QuickConfigureTool failed to set up pause menu button: " + ex.Message);
			}
		}

		public static void OnShowButtonChanged(object s, EventArgs e)
		{
			bool value = ValConfig.ShowQuickConfigureButton.Value;
			if ((Object)(object)mainMenuButton != (Object)null)
			{
				mainMenuButton.SetActive(value);
			}
			if ((Object)(object)pauseMenuButton != (Object)null)
			{
				pauseMenuButton.SetActive(value && SynchronizationManager.Instance.PlayerIsAdmin);
			}
		}

		private static void CreateMainMenuButton()
		{
			if (!((Object)(object)mainMenuButton != (Object)null) && !((Object)(object)GUIManager.CustomGUIFront == (Object)null))
			{
				mainMenuButton = CreateCornerButton(GUIManager.CustomGUIFront.transform);
				mainMenuButton.SetActive(ValConfig.ShowQuickConfigureButton.Value);
			}
		}

		private static GameObject CreateCornerButton(Transform parent)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			GameObject obj = GUIManager.Instance.CreateButton("SLS Config", parent, new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(-20f, 20f), 150f, 38f);
			RectTransform val = (RectTransform)obj.transform;
			val.pivot = new Vector2(1f, 0f);
			val.anchoredPosition = new Vector2(-20f, 20f);
			((UnityEvent)obj.GetComponent<Button>().onClick).AddListener(new UnityAction(OpenPanel));
			return obj;
		}

		internal static void OpenPanel()
		{
			staged = StagedConfig.Snapshot();
			if ((Object)(object)panel != (Object)null)
			{
				Object.Destroy((Object)(object)panel);
				panel = null;
			}
			try
			{
				BuildPanel();
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"QuickConfigureTool failed to build panel: {arg}");
				if ((Object)(object)panel != (Object)null)
				{
					Object.Destroy((Object)(object)panel);
					panel = null;
				}
				return;
			}
			currentPage = 0;
			ShowPage(0);
		}

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

		private static void BuildPanel()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			panel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 900f, 690f, true);
			titleText = AddText(panel.transform, 26f, 18f, 848f, 34f, "StarLevelSystem - Quick Configure", 22, (TextAnchor)4, GUIManager.Instance.ValheimYellow);
			pageRoots = (GameObject[])(object)new GameObject[5];
			for (int i = 0; i < 5; i++)
			{
				pageRoots[i] = NewRect("Page" + i, panel.transform, 26f, 92f, 848f, 528f);
			}
			BuildScalingPage(pageRoots[0].transform);
			BuildStatsPage(pageRoots[1].transform);
			BuildModifiersPage(pageRoots[2].transform);
			BuildRaidsPage(pageRoots[3].transform);
			BuildNemesisPage(pageRoots[4].transform);
			float y = 634f;
			Transform transform = panel.transform;
			object obj = <>c.<>9__38_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					ShowPage(currentPage - 1);
				};
				<>c.<>9__38_0 = val;
				obj = (object)val;
			}
			backBtn = AddButton(transform, 26f, y, 130f, "< Back", (UnityAction)obj);
			cancelBtn = AddButton(panel.transform, 176f, y, 130f, "Cancel", new UnityAction(ClosePanel));
			Transform transform2 = panel.transform;
			object obj2 = <>c.<>9__38_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					ShowPage(currentPage + 1);
				};
				<>c.<>9__38_1 = val2;
				obj2 = (object)val2;
			}
			nextBtn = AddButton(transform2, 704f, y, 170f, "Next >", (UnityAction)obj2);
			applyBtn = AddButton(panel.transform, 704f, y, 170f, "Apply & Save", new UnityAction(ApplyAndSave));
		}

		private static void ShowPage(int page)
		{
			currentPage = Mathf.Clamp(page, 0, 4);
			for (int i = 0; i < pageRoots.Length; i++)
			{
				pageRoots[i].SetActive(i == currentPage);
			}
			string[] array = new string[5] { "Scaling Mechanisms", "Stats & Level Generator", "Modifiers", "Raids", "Nemesis System" };
			titleText.text = $"StarLevelSystem - {array[currentPage]}  (Page {currentPage + 1} of {5})";
			backBtn.SetActive(currentPage > 0);
			bool flag = currentPage == 4;
			nextBtn.SetActive(!flag);
			applyBtn.SetActive(flag);
			if (currentPage == 1)
			{
				UpdateExampleMath();
			}
		}

		private static void BuildScalingPage(Transform parent)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> rows = new List<GameObject>
			{
				AddHeaderRow(parent, 460f, "$sls_cfg_scaling_selection_header", (TextAnchor)4),
				AddTextRow(parent, 760f, 34f, "Here are some high level configurations from the mod, many more things can be customized within the yaml configuration.", 13, GUIManager.Instance.ValheimBeige, (TextAnchor)1),
				AddScalingFeatureRow(parent, 760f, 300f, 168f, DistanceExample, "$sls_cfg_distance_scale_header", "$sls_cfg_distance_scale_desc", staged.enableDistance, delegate(bool v)
				{
					staged.enableDistance = v;
				}, "$sls_cfg_distance_overlay_toggle", staged.enableDistanceOverlay, delegate(bool v)
				{
					staged.enableDistanceOverlay = v;
				}),
				AddDividerRow(parent, 760f),
				AddScalingFeatureRow(parent, 760f, 300f, 168f, ZoneExample, "$sls_cfg_zone_scale_header", "$sls_cfg_zone_scale_desc", staged.enableZone, delegate(bool v)
				{
					staged.enableZone = v;
				}, "$sls_cfg_zone_overlay_toggle", staged.enableZoneOverlay, delegate(bool v)
				{
					staged.enableZoneOverlay = v;
				}),
				AddDividerRow(parent, 760f),
				AddToggleRow(parent, 760f, 360f, "$sls_cfg_conditional_scale_header", staged.enableConditional, delegate(bool v)
				{
					staged.enableConditional = v;
				}, toggleOnLeft: true),
				AddTextRow(parent, 760f, 24f, "$sls_cfg_conditional_scale_desc", 13, GUIManager.Instance.ValheimBeige, (TextAnchor)0)
			};
			float x = Mathf.Max(0f, 44f);
			LayoutColumn(rows, x, 4f);
		}

		private static void BuildStatsPage(Transform parent)
		{
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			LayoutColumn(new List<GameObject>
			{
				AddHeaderRow(parent, 430f, "Per-level stats", (TextAnchor)3),
				AddSliderRow(parent, 430f, 168f, 150f, 60f, "Creature HP / level", 0f, 5f, staged.creatureHpPerLevel, wholeNumbers: false, delegate(float v)
				{
					staged.creatureHpPerLevel = v;
					UpdateExampleMath();
				}),
				AddSliderRow(parent, 430f, 168f, 150f, 60f, "Creature dmg / level", 0f, 2f, staged.creatureDmgPerLevel, wholeNumbers: false, delegate(float v)
				{
					staged.creatureDmgPerLevel = v;
					UpdateExampleMath();
				}),
				AddSliderRow(parent, 430f, 168f, 150f, 60f, "Max level (stars)", 1f, 200f, staged.maxLevel, wholeNumbers: true, delegate(float v)
				{
					staged.maxLevel = (int)v;
					UpdateExampleMath();
				}),
				AddDividerRow(parent, 848f),
				AddSliderRow(parent, 430f, 168f, 150f, 60f, "Boss HP / level", 0f, 5f, staged.bossHpPerLevel, wholeNumbers: false, delegate(float v)
				{
					staged.bossHpPerLevel = v;
					UpdateExampleMath();
				}),
				AddSliderRow(parent, 430f, 168f, 150f, 60f, "Boss dmg / level", 0f, 5f, staged.bossDmgPerLevel, wholeNumbers: false, delegate(float v)
				{
					staged.bossDmgPerLevel = v;
					UpdateExampleMath();
				}),
				AddSliderRow(parent, 430f, 168f, 150f, 60f, "Max boss level", 1f, 200f, staged.maxBossLevel, wholeNumbers: true, delegate(float v)
				{
					staged.maxBossLevel = (int)v;
					UpdateExampleMath();
				}),
				AddSpacerRow(parent, 430f, 4f),
				AddHeaderRow(parent, 430f, "Multiplayer scaling", (TextAnchor)3),
				AddToggleRow(parent, 430f, 338f, "Enemies gain HP with more players", staged.mpHealth, delegate(bool v)
				{
					staged.mpHealth = v;
				}),
				AddSliderRow(parent, 430f, 168f, 150f, 60f, "HP per extra player", 0f, 0.99f, staged.mpHealthMod, wholeNumbers: false, delegate(float v)
				{
					staged.mpHealthMod = v;
				}),
				AddToggleRow(parent, 430f, 338f, "Enemies gain dmg with more players", staged.mpDamage, delegate(bool v)
				{
					staged.mpDamage = v;
				}),
				AddSliderRow(parent, 430f, 168f, 150f, 60f, "Dmg per extra player", 0f, 2f, staged.mpDamageMod, wholeNumbers: false, delegate(float v)
				{
					staged.mpDamageMod = v;
				}),
				AddSliderRow(parent, 430f, 168f, 150f, 60f, "Players needed nearby", 1f, 20f, staged.mpRequiredPlayers, wholeNumbers: true, delegate(float v)
				{
					staged.mpRequiredPlayers = (int)v;
				})
			}, 0f, 2f);
			PositionRow(AddHeaderRow(parent, 398f, "Example scaling preview", (TextAnchor)3), 450f, 2f);
			GameObject obj = AddTextRow(parent, 398f, 80f, "", 15, GUIManager.Instance.ValheimBeige, (TextAnchor)0);
			creatureExampleText = obj.GetComponentInChildren<Text>();
			PositionRow(obj, 450f, 40f);
			float num = 16f;
			GameObject obj2 = AddTextRow(parent, 398f, 80f, "", 15, GUIManager.Instance.ValheimBeige, (TextAnchor)0);
			bossExampleText = obj2.GetComponentInChildren<Text>();
			PositionRow(obj2, 450f, 154f + num);
			float genStartY = 230f + num + 8f;
			GameObject gaussianRow = null;
			List<GameObject> gen = new List<GameObject>
			{
				AddHeaderRow(parent, 398f, "Default level generator", (TextAnchor)3),
				AddSliderRow(parent, 398f, 168f, 150f, 60f, "Min level", 1f, 50f, staged.generator.MinLevel, wholeNumbers: true, delegate(float v)
				{
					staged.generator.MinLevel = (int)v;
				}),
				AddSliderRow(parent, 398f, 168f, 150f, 60f, "Max level", 1f, 200f, staged.generator.MaxLevel, wholeNumbers: true, delegate(float v)
				{
					staged.generator.MaxLevel = (int)v;
				}),
				AddSliderRow(parent, 398f, 168f, 150f, 60f, "Level-up chance", 0f, 1f, staged.generator.LevelUpChance, wholeNumbers: false, delegate(float v)
				{
					staged.generator.LevelUpChance = v;
				})
			};
			gen.Add(AddEnumCycleRow(parent, 398f, 168f, 150f, "Curve style", CalcStyleOptions, (int)staged.generator.LevelupCalculationStyle, delegate(int i)
			{
				staged.generator.LevelupCalculationStyle = (DataObjects.LevelupCalculationStyle)i;
				if ((Object)(object)gaussianRow != (Object)null)
				{
					gaussianRow.SetActive(i == 0);
					LayoutColumn(gen, 450f, genStartY);
				}
			}));
			gaussianRow = AddSliderRow(parent, 398f, 168f, 150f, 60f, "Gaussian offset", -1f, 1f, staged.generator.GaussianOffset, wholeNumbers: false, delegate(float v)
			{
				staged.generator.GaussianOffset = v;
			});
			gen.Add(gaussianRow);
			gen.Add(AddSliderRow(parent, 398f, 168f, 150f, 60f, "Night multiplier", 0f, 5f, staged.generator.NightMultiplier, wholeNumbers: false, delegate(float v)
			{
				staged.generator.NightMultiplier = v;
			}));
			gaussianRow.SetActive(staged.generator.LevelupCalculationStyle == DataObjects.LevelupCalculationStyle.Gaussian);
			LayoutColumn(gen, 450f, genStartY);
			UpdateExampleMath();
		}

		private static void BuildRaidsPage(Transform parent)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			PositionRow(AddHeaderRow(parent, 848f, "Raids", (TextAnchor)4), 0f, 4f);
			PositionRow(AddTextRow(parent, 848f, 40f, "StarLevelSystem replaces vanilla raids with its own configurable raids. Detailed per-raid settings live in RaidSettings.yaml.", 13, GUIManager.Instance.ValheimBeige, (TextAnchor)1), 0f, 42f);
			float num = 90f;
			LayoutColumn(new List<GameObject>
			{
				AddToggleRow(parent, 430f, 300f, "Enable SLS Raids", staged.enableSlsRaids, delegate(bool v)
				{
					staged.enableSlsRaids = v;
				}, toggleOnLeft: true),
				AddSliderRow(parent, 430f, 235f, 130f, 56f, "Raid frequency (lower = more often)", 0.1f, 10f, staged.raidEventRate, wholeNumbers: false, delegate(float v)
				{
					staged.raidEventRate = v;
				}),
				AddSliderRow(parent, 430f, 235f, 130f, 56f, "Minutes between checks", 1f, 120f, staged.raidCheckMinutes, wholeNumbers: true, delegate(float v)
				{
					staged.raidCheckMinutes = (int)v;
				}),
				AddSliderRow(parent, 430f, 235f, 130f, 56f, "Max attempts / player", 0f, 50f, staged.maxRaidAttempts, wholeNumbers: true, delegate(float v)
				{
					staged.maxRaidAttempts = (int)v;
				}),
				AddSliderRow(parent, 430f, 235f, 130f, 56f, "Max active raids", 1f, 20f, staged.maxActiveRaids, wholeNumbers: true, delegate(float v)
				{
					staged.maxActiveRaids = (int)v;
				})
			}, 0f, num);
			AddText(parent, 446f, num, 402f, 34f, "Enable / disable raids", 16, (TextAnchor)3, GUIManager.Instance.ValheimYellow);
			GameObject val = NewRect("RaidScrollHolder", parent, 446f, num + 34f, 402f, 398f);
			Transform val2 = GUIManager.Instance.CreateScrollView(val.transform, false, true, 8f, 4f, GUIManager.Instance.ValheimScrollbarHandleColorBlock, new Color(0f, 0f, 0f, 0.5f), 402f, 398f).transform.Find("Scroll View/Viewport/Content");
			if (!((Object)(object)val2 != (Object)null))
			{
				return;
			}
			float width = 386f;
			List<DataObjects.RaidDefinition> list = staged.raidSource?.Raids;
			if (list == null)
			{
				return;
			}
			foreach (DataObjects.RaidDefinition item in list.OrderBy((DataObjects.RaidDefinition r) => r.Name))
			{
				string raidName = item.Name;
				AddRaidEntry(val2, width, item, staged.raidsOn.Contains(raidName), delegate(bool on)
				{
					if (on)
					{
						staged.raidsOn.Add(raidName);
					}
					else
					{
						staged.raidsOn.Remove(raidName);
					}
				});
			}
		}

		private static void AddRaidEntry(Transform content, float width, DataObjects.RaidDefinition raid, bool enabled, Action<bool> onChange)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = NewLayoutRow(content, width, 44f);
			GameObject obj = GUIManager.Instance.CreateToggle(val.transform, 22f, 22f);
			obj.transform.SetParent(val.transform, false);
			RectTransform val2 = (RectTransform)obj.transform;
			((Transform)val2).localScale = Vector3.one;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.anchoredPosition = new Vector2(2f, -3f);
			Toggle component = obj.GetComponent<Toggle>();
			component.isOn = enabled;
			((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)delegate(bool b)
			{
				onChange(b);
			});
			AddText(val.transform, 32f, 0f, width - 32f - 4f, 20f, PrettifyRaidName(raid.Name), 14, (TextAnchor)3, GUIManager.Instance.ValheimOrange);
			int num = ((raid.Spawns != null) ? raid.Spawns.Select((DataObjects.RaidSpawnEntry sp) => sp.PrefabName).Distinct().Count() : 0);
			string text = string.Format("{0} creature type{1}  ·  {2:0}s", num, (num == 1) ? "" : "s", raid.Duration);
			AddText(val.transform, 32f, 20f, width - 32f - 4f, 24f, text, 12, (TextAnchor)0, GUIManager.Instance.ValheimBeige);
		}

		private static string PrettifyRaidName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return name;
			}
			return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(name.Replace('_', ' '));
		}

		private static void BuildNemesisPage(Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			PositionRow(AddTextRow(parent, 848f, 40f, "The Nemesis system is a personal game manager that can tune up or down the world around you or your group.", 14, GUIManager.Instance.ValheimBeige, (TextAnchor)0), 0f, 4f);
			float startY = 48f;
			LayoutColumn(new List<GameObject>
			{
				AddHeaderRow(parent, 400f, "Nemesis settings", (TextAnchor)3),
				AddToggleRow(parent, 400f, 260f, "Enable Nemesis system", staged.enableNemesis, delegate(bool v)
				{
					staged.enableNemesis = v;
				}),
				AddSliderRow(parent, 400f, 200f, 130f, 60f, "Action cooldown (sec)", 0f, 120f, staged.nemCooldown, wholeNumbers: false, delegate(float v)
				{
					staged.nemCooldown = v;
				}),
				AddSliderRow(parent, 400f, 200f, 130f, 60f, "Influence radius (m)", 0f, 1000f, staged.nemInfluence, wholeNumbers: false, delegate(float v)
				{
					staged.nemInfluence = v;
				}),
				AddSliderRow(parent, 400f, 200f, 130f, 60f, "Min spawn distance (m)", 0f, 500f, staged.nemMinSpawn, wholeNumbers: false, delegate(float v)
				{
					staged.nemMinSpawn = v;
				})
			}, 0f, startY);
			LayoutColumn(new List<GameObject>
			{
				AddHeaderRow(parent, 408f, "Score system", (TextAnchor)3),
				AddSliderRow(parent, 408f, 210f, 120f, 60f, "Neutral score", 0f, 20000f, staged.neutralScore, wholeNumbers: true, delegate(float v)
				{
					staged.neutralScore = v;
				}),
				AddSliderRow(parent, 408f, 210f, 120f, 60f, "Min score", 0f, 20000f, staged.minScore, wholeNumbers: true, delegate(float v)
				{
					staged.minScore = v;
				}),
				AddSliderRow(parent, 408f, 210f, 120f, 60f, "Max score", 0f, 20000f, staged.maxScore, wholeNumbers: true, delegate(float v)
				{
					staged.maxScore = v;
				}),
				AddSliderRow(parent, 408f, 210f, 120f, 60f, "Decay per update", 0f, 2000f, staged.decayPerUpdate, wholeNumbers: true, delegate(float v)
				{
					staged.decayPerUpdate = v;
				}),
				AddSliderRow(parent, 408f, 210f, 120f, 60f, "Score interval (sec)", 1f, 120f, staged.scoreInterval, wholeNumbers: true, delegate(float v)
				{
					staged.scoreInterval = v;
				}),
				AddSliderRow(parent, 408f, 210f, 120f, 60f, "Boss-kill bonus", 0f, 5000f, staged.bossKillBonus, wholeNumbers: true, delegate(float v)
				{
					staged.bossKillBonus = v;
				}),
				AddSliderRow(parent, 408f, 210f, 120f, 60f, "Death score reduction", 0f, 5000f, staged.deathReduction, wholeNumbers: true, delegate(float v)
				{
					staged.deathReduction = v;
				})
			}, 440f, startY);
		}

		private static void BuildModifiersPage(Transform parent)
		{
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			LayoutColumn(new List<GameObject>
			{
				AddHeaderRow(parent, 430f, "Creature modifiers", (TextAnchor)3),
				AddSliderRow(parent, 430f, 200f, 120f, 56f, "Max major modifiers", 0f, 6f, staged.maxMajor, wholeNumbers: true, delegate(float v)
				{
					staged.maxMajor = (int)v;
				}),
				AddSliderRow(parent, 430f, 200f, 120f, 56f, "Max minor modifiers", 0f, 6f, staged.maxMinor, wholeNumbers: true, delegate(float v)
				{
					staged.maxMinor = (int)v;
				}),
				AddSliderRow(parent, 430f, 200f, 120f, 56f, "Major modifier chance", 0f, 1f, staged.chanceMajor, wholeNumbers: false, delegate(float v)
				{
					staged.chanceMajor = v;
				}),
				AddSliderRow(parent, 430f, 200f, 120f, 56f, "Minor modifier chance", 0f, 1f, staged.chanceMinor, wholeNumbers: false, delegate(float v)
				{
					staged.chanceMinor = v;
				}),
				AddToggleRow(parent, 430f, 300f, "Limit modifier count to star level", staged.limitToStarLevel, delegate(bool v)
				{
					staged.limitToStarLevel = v;
				}),
				AddHeaderRow(parent, 430f, "Boss modifiers", (TextAnchor)3),
				AddToggleRow(parent, 430f, 300f, "Bosses can have modifiers", staged.enableBossMods, delegate(bool v)
				{
					staged.enableBossMods = v;
				}),
				AddSliderRow(parent, 430f, 200f, 120f, 56f, "Boss modifier chance", 0f, 1f, staged.chanceBoss, wholeNumbers: false, delegate(float v)
				{
					staged.chanceBoss = v;
				}),
				AddSliderRow(parent, 430f, 200f, 120f, 56f, "Max boss modifiers", 0f, 6f, staged.maxBossMods, wholeNumbers: true, delegate(float v)
				{
					staged.maxBossMods = (int)v;
				}),
				AddHeaderRow(parent, 430f, "Modifier display", (TextAnchor)3),
				AddSliderRow(parent, 430f, 200f, 120f, 56f, "Max name prefixes", 0f, 6f, staged.prefixLimit, wholeNumbers: true, delegate(float v)
				{
					staged.prefixLimit = (int)v;
				}),
				AddToggleRow(parent, 430f, 300f, "Minor modifiers first in name", staged.minorFirst, delegate(bool v)
				{
					staged.minorFirst = v;
				}),
				AddEnumCycleRow(parent, 430f, 200f, 150f, "Icon display style", DisplayStyleOptions, (int)staged.displayStyle, delegate(int i)
				{
					staged.displayStyle = (DataObjects.ModifierDisplayStyle)i;
				})
			}, 0f, 4f);
			AddText(parent, 446f, 4f, 400f, 34f, "Enable / disable modifiers", 16, (TextAnchor)3, GUIManager.Instance.ValheimYellow);
			GameObject val = NewRect("ModScrollHolder", parent, 446f, 38f, 400f, 478f);
			Transform val2 = GUIManager.Instance.CreateScrollView(val.transform, false, true, 8f, 4f, GUIManager.Instance.ValheimScrollbarHandleColorBlock, new Color(0f, 0f, 0f, 0.5f), 400f, 478f).transform.Find("Scroll View/Viewport/Content");
			if ((Object)(object)val2 != (Object)null)
			{
				float width = 384f;
				AddModifierCategory(val2, width, "Boss modifiers", DataObjects.ModifierType.Boss, staged.modifierSource?.BossModifiers);
				AddModifierCategory(val2, width, "Major modifiers", DataObjects.ModifierType.Major, staged.modifierSource?.MajorModifiers);
				AddModifierCategory(val2, width, "Minor modifiers", DataObjects.ModifierType.Minor, staged.modifierSource?.MinorModifiers);
			}
		}

		private static void AddModifierCategory(Transform content, float width, string label, DataObjects.ModifierType type, Dictionary<string, DataObjects.CreatureModifierConfiguration> dict)
		{
			if (dict == null || dict.Count == 0)
			{
				return;
			}
			AddModifierCategoryHeader(content, width, label);
			HashSet<string> hashSet = staged.modifierOn[type];
			foreach (string item in dict.Keys.OrderBy((string n) => n))
			{
				string modName = item;
				AddModifierEntry(content, width, modName, hashSet.Contains(modName), delegate(bool on)
				{
					if (on)
					{
						staged.modifierOn[type].Add(modName);
					}
					else
					{
						staged.modifierOn[type].Remove(modName);
					}
				});
			}
		}

		private static void AddModifierCategoryHeader(Transform content, float width, string label)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			AddText(NewLayoutRow(content, width, 30f).transform, 2f, 4f, width - 4f, 24f, label, 16, (TextAnchor)3, GUIManager.Instance.ValheimYellow);
		}

		private static void AddModifierEntry(Transform content, float width, string name, bool enabled, Action<bool> onChange)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = NewLayoutRow(content, width, 48f);
			GameObject obj = GUIManager.Instance.CreateToggle(val.transform, 22f, 22f);
			obj.transform.SetParent(val.transform, false);
			RectTransform val2 = (RectTransform)obj.transform;
			((Transform)val2).localScale = Vector3.one;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.anchoredPosition = new Vector2(2f, -3f);
			Toggle component = obj.GetComponent<Toggle>();
			component.isOn = enabled;
			((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)delegate(bool b)
			{
				onChange(b);
			});
			AddText(val.transform, 32f, 0f, width - 32f - 4f, 20f, Prettify(name), 14, (TextAnchor)3, GUIManager.Instance.ValheimOrange);
			string value;
			string text = (ModifierDescriptions.TryGetValue(name, out value) ? value : "");
			AddText(val.transform, 32f, 20f, width - 32f - 4f, 26f, text, 12, (TextAnchor)0, GUIManager.Instance.ValheimBeige);
		}

		private static GameObject NewLayoutRow(Transform content, float width, float height)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			GameObject val = new GameObject("ModRow", new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			})
			{
				layer = 5
			};
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			((Transform)component).SetParent(content, false);
			component.sizeDelta = new Vector2(width, height);
			LayoutElement component2 = val.GetComponent<LayoutElement>();
			component2.minHeight = height;
			component2.preferredHeight = height;
			component2.minWidth = width;
			component2.preferredWidth = width;
			return val;
		}

		private static string Prettify(string name)
		{
			return Regex.Replace(name, "(\\B[A-Z])", " $1");
		}

		private static void UpdateExampleMath()
		{
			if (staged != null)
			{
				if ((Object)(object)creatureExampleText != (Object)null)
				{
					int num = Mathf.Max(0, staged.maxLevel);
					int medStars = Mathf.Max(0, Mathf.CeilToInt((float)num / 2f));
					creatureExampleText.text = FormatCreatureExample("Troll", 600f, 70f, medStars, num, staged.creatureHpPerLevel, staged.creatureDmgPerLevel);
				}
				if ((Object)(object)bossExampleText != (Object)null)
				{
					int num2 = Mathf.Max(0, staged.maxBossLevel);
					int medStars2 = Mathf.Max(0, Mathf.CeilToInt((float)num2 / 2f));
					bossExampleText.text = FormatCreatureExample("The Elder (boss)", 2500f, 60f, medStars2, num2, staged.bossHpPerLevel, staged.bossDmgPerLevel);
				}
			}
		}

		private static string FormatCreatureExample(string name, float baseHp, float baseDmg, int medStars, int maxStars, float hpMul, float dmgMul)
		{
			return $"{name} (base {baseHp:0} HP / {baseDmg:0} dmg)\n" + $"  Min (0 stars):   {Hp(0):0} HP    {Dmg(0):0} dmg\n" + $"  Median ({medStars} stars):   {Hp(medStars):0} HP    {Dmg(medStars):0} dmg\n" + $"  Max ({maxStars} stars):   {Hp(maxStars):0} HP    {Dmg(maxStars):0} dmg\n";
			float Dmg(int stars)
			{
				return baseDmg * (1f + dmgMul * (float)stars);
			}
			float Hp(int stars)
			{
				return baseHp * (1f + hpMul * (float)stars);
			}
		}

		private static void ApplyAndSave()
		{
			try
			{
				ValConfig.EnableDistanceLevelScalingBonus.Value = staged.enableDistance;
				ValConfig.EnableMapRingsForDistanceBonus.Value = staged.enableDistanceOverlay;
				ValConfig.EnableZoneScalingBonus.Value = staged.enableZone;
				ValConfig.EnableZoneMapOverlay.Value = staged.enableZoneOverlay;
				ValConfig.EnemyHealthMultiplier.Value = staged.creatureHpPerLevel;
				ValConfig.EnemyDamageLevelMultiplier.Value = staged.creatureDmgPerLevel;
				ValConfig.BossEnemyHealthMultiplier.Value = staged.bossHpPerLevel;
				ValConfig.BossEnemyDamageMultiplier.Value = staged.bossDmgPerLevel;
				ValConfig.MaxLevel.Value = staged.maxLevel;
				ValConfig.MaxBossLevel.Value = staged.maxBossLevel;
				ValConfig.EnableMultiplayerEnemyHealthScaling.Value = staged.mpHealth;
				ValConfig.MultiplayerEnemyHealthModifier.Value = staged.mpHealthMod;
				ValConfig.EnableMultiplayerEnemyDamageScaling.Value = staged.mpDamage;
				ValConfig.MultiplayerEnemyDamageModifier.Value = staged.mpDamageMod;
				ValConfig.MultiplayerScalingRequiredPlayersNearby.Value = staged.mpRequiredPlayers;
				ValConfig.MaxMajorModifiersPerCreature.Value = staged.maxMajor;
				ValConfig.MaxMinorModifiersPerCreature.Value = staged.maxMinor;
				ValConfig.ChanceMajorModifier.Value = staged.chanceMajor;
				ValConfig.ChanceMinorModifier.Value = staged.chanceMinor;
				ValConfig.LimitCreatureModifiersToCreatureStarLevel.Value = staged.limitToStarLevel;
				ValConfig.EnableBossModifiers.Value = staged.enableBossMods;
				ValConfig.ChanceOfBossModifier.Value = staged.chanceBoss;
				ValConfig.MaxBossModifiersPerBoss.Value = staged.maxBossMods;
				ValConfig.LimitCreatureModifierPrefixes.Value = staged.prefixLimit;
				ValConfig.MinorModifiersFirstInName.Value = staged.minorFirst;
				ValConfig.ModifierIconDisplayStyle.Value = staged.displayStyle.ToString();
				DataObjects.CreatureLevelSettings sLE_Level_Settings = LevelSystemData.SLE_Level_Settings;
				if (sLE_Level_Settings != null)
				{
					sLE_Level_Settings.EnableConditionalCreatureLevelupChance = staged.enableConditional;
					sLE_Level_Settings.DefaultLevelupGenerators = new List<DataObjects.LevelGenerator> { staged.generator };
					string text = DataObjects.yamlSerializer.Serialize((object)sLE_Level_Settings);
					File.WriteAllText(ValConfig.levelsFilePath, text);
					LevelSystemData.UpdateYamlConfig(text);
				}
				if (ModifiersChanged())
				{
					DataObjects.CreatureModifierCollection modifierSource = staged.modifierSource;
					ApplyEnabledFlags(modifierSource.BossModifiers, staged.modifierOn[DataObjects.ModifierType.Boss]);
					ApplyEnabledFlags(modifierSource.MajorModifiers, staged.modifierOn[DataObjects.ModifierType.Major]);
					ApplyEnabledFlags(modifierSource.MinorModifiers, staged.modifierOn[DataObjects.ModifierType.Minor]);
					string text2 = DataObjects.yamlSerializer.Serialize((object)modifierSource);
					File.WriteAllText(ValConfig.creatureModifierFilePath, text2);
					CreatureModifiersData.UpdateModifierConfig(text2);
					CreatureModifiersData.ClearProbabilityCaches();
				}
				ValConfig.UseVanillaRaidConfiguration.Value = !staged.enableSlsRaids;
				ValConfig.RaidEventRate.Value = staged.raidEventRate;
				ValConfig.ServerTimeBetweenRaidStartChecks.Value = staged.raidCheckMinutes;
				ValConfig.MaxRaidAttemptsPerPlayer.Value = staged.maxRaidAttempts;
				ValConfig.MaxActiveRaids.Value = staged.maxActiveRaids;
				if (RaidsChanged())
				{
					DataObjects.RaidConfiguration raidConfiguration = DataObjects.yamlDeserializer.Deserialize<DataObjects.RaidConfiguration>(DataObjects.yamlSerializer.Serialize((object)staged.raidSource));
					foreach (DataObjects.RaidDefinition raid in raidConfiguration.Raids)
					{
						raid.Enabled = staged.raidsOn.Contains(raid.Name);
					}
					string text3 = DataObjects.yamlSerializer.Serialize((object)raidConfiguration);
					File.WriteAllText(ValConfig.raidsFilePath, text3);
					RaidsData.UpdateYamlConfig(text3);
				}
				ValConfig.EnableNemesisSystem.Value = staged.enableNemesis;
				if (NemesisChanged())
				{
					DataObjects.NemesisConfiguration nemesisConfiguration = DataObjects.yamlDeserializer.Deserialize<DataObjects.NemesisConfiguration>(DataObjects.yamlSerializer.Serialize((object)staged.nemesisSource));
					nemesisConfiguration.NemesisActionCooldownSeconds = staged.nemCooldown;
					nemesisConfiguration.NemesisInfluenceRadius = staged.nemInfluence;
					nemesisConfiguration.NemesisMinSpawnDistance = staged.nemMinSpawn;
					if (nemesisConfiguration.ScoreSystem == null)
					{
						nemesisConfiguration.ScoreSystem = new DataObjects.NemesisScore();
					}
					nemesisConfiguration.ScoreSystem.NeutralScore = staged.neutralScore;
					nemesisConfiguration.ScoreSystem.MinScore = staged.minScore;
					nemesisConfiguration.ScoreSystem.MaxScore = staged.maxScore;
					nemesisConfiguration.ScoreSystem.DecayPerUpdate = staged.decayPerUpdate;
					nemesisConfiguration.ScoreSystem.ScoreIntervalSeconds = staged.scoreInterval;
					nemesisConfiguration.ScoreSystem.BossKillBonus = staged.bossKillBonus;
					nemesisConfiguration.ScoreSystem.DeathScoreReduction = staged.deathReduction;
					string text4 = DataObjects.yamlSerializer.Serialize((object)nemesisConfiguration);
					File.WriteAllText(ValConfig.nemesisFilePath, text4);
					NemesisSystemData.UpdateYamlConfig(text4);
				}
				Logger.LogInfo("QuickConfigureTool applied and saved configuration.");
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"QuickConfigureTool failed to apply configuration: {arg}");
			}
			ClosePanel();
		}

		private static bool ModifiersChanged()
		{
			if (staged?.modifierSource == null)
			{
				return false;
			}
			if (!EnabledDiffers(staged.modifierSource.BossModifiers, staged.modifierOn[DataObjects.ModifierType.Boss]) && !EnabledDiffers(staged.modifierSource.MajorModifiers, staged.modifierOn[DataObjects.ModifierType.Major]))
			{
				return EnabledDiffers(staged.modifierSource.MinorModifiers, staged.modifierOn[DataObjects.ModifierType.Minor]);
			}
			return true;
		}

		private static bool EnabledDiffers(Dictionary<string, DataObjects.CreatureModifierConfiguration> dict, HashSet<string> enabledNames)
		{
			if (dict == null)
			{
				return false;
			}
			foreach (KeyValuePair<string, DataObjects.CreatureModifierConfiguration> item in dict)
			{
				if (item.Value.Enabled != enabledNames.Contains(item.Key))
				{
					return true;
				}
			}
			return false;
		}

		private static void ApplyEnabledFlags(Dictionary<string, DataObjects.CreatureModifierConfiguration> dict, HashSet<string> enabledNames)
		{
			if (dict == null)
			{
				return;
			}
			foreach (KeyValuePair<string, DataObjects.CreatureModifierConfiguration> item in dict)
			{
				item.Value.Enabled = enabledNames.Contains(item.Key);
			}
		}

		private static bool NemesisChanged()
		{
			DataObjects.NemesisConfiguration nemesisConfiguration = staged?.nemesisSource;
			if (nemesisConfiguration == null)
			{
				return false;
			}
			DataObjects.NemesisScore nemesisScore = nemesisConfiguration.ScoreSystem ?? new DataObjects.NemesisScore();
			if (nemesisConfiguration.NemesisActionCooldownSeconds == staged.nemCooldown && nemesisConfiguration.NemesisInfluenceRadius == staged.nemInfluence && nemesisConfiguration.NemesisMinSpawnDistance == staged.nemMinSpawn && nemesisScore.NeutralScore == staged.neutralScore && nemesisScore.MinScore == staged.minScore && nemesisScore.MaxScore == staged.maxScore && nemesisScore.DecayPerUpdate == staged.decayPerUpdate && nemesisScore.ScoreIntervalSeconds == staged.scoreInterval && nemesisScore.BossKillBonus == staged.bossKillBonus)
			{
				return nemesisScore.DeathScoreReduction != staged.deathReduction;
			}
			return true;
		}

		private static bool RaidsChanged()
		{
			if (staged?.raidSource?.Raids == null)
			{
				return false;
			}
			foreach (DataObjects.RaidDefinition raid in staged.raidSource.Raids)
			{
				if (raid.Enabled != staged.raidsOn.Contains(raid.Name))
				{
					return true;
				}
			}
			return false;
		}

		private static GameObject NewRect(string name, Transform parent, float x, float y, float w, float h)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			component.sizeDelta = new Vector2(w, h);
			component.anchoredPosition = new Vector2(x, 0f - y);
			return val;
		}

		private static Text AddText(Transform parent, float x, float y, float w, float h, string text, int fontSize, TextAnchor anchor, Color? color = null)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			Text component = GUIManager.Instance.CreateText(Localization.instance.Localize(text), parent, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(x, 0f - y), GUIManager.Instance.AveriaSerifBold, fontSize, (Color)(((??)color) ?? GUIManager.Instance.ValheimBeige), true, Color.black, w, h, false).GetComponent<Text>();
			RectTransform rectTransform = ((Graphic)component).rectTransform;
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.anchoredPosition = new Vector2(x, 0f - y);
			component.alignment = anchor;
			component.horizontalOverflow = (HorizontalWrapMode)0;
			component.verticalOverflow = (VerticalWrapMode)1;
			return component;
		}

		private static GameObject NewRow(Transform parent, float width, float height)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			GameObject val = new GameObject("Row", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			component.sizeDelta = new Vector2(width, height);
			component.anchoredPosition = new Vector2(0f, 0f);
			return val;
		}

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

		private static void PositionRow(GameObject row, float x, float y)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			((RectTransform)row.transform).anchoredPosition = new Vector2(x, 0f - y);
		}

		private static GameObject AddHeaderRow(Transform parent, float colWidth, string text, TextAnchor anchor = (TextAnchor)3)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = NewRow(parent, colWidth, 34f);
			AddText(obj.transform, 0f, 0f, colWidth, 34f, text, 18, anchor, GUIManager.Instance.ValheimYellow);
			return obj;
		}

		private static GameObject AddDividerRow(Transform parent, float colWidth, float height = 12f)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = NewRow(parent, colWidth, height);
			GameObject obj = NewUI("Divider", val.transform, typeof(Image));
			RectTransform val2 = (RectTransform)obj.transform;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.sizeDelta = new Vector2(colWidth, 2f);
			val2.anchoredPosition = new Vector2(0f, 0f - (height * 0.5f - 1f));
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = new Color(0.6f, 0.5f, 0.35f, 0.6f);
			((Graphic)component).raycastTarget = false;
			return val;
		}

		private static GameObject AddTextRow(Transform parent, float colWidth, float height, string text, int fontSize, Color color, TextAnchor anchor = (TextAnchor)0)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = NewRow(parent, colWidth, height);
			AddText(obj.transform, 0f, 0f, colWidth, height, text, fontSize, anchor, color);
			return obj;
		}

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

		private static GameObject AddButton(Transform parent, float x, float y, float w, string text, UnityAction onClick)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GUIManager.Instance.CreateButton(text, parent, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(x, 0f - y), w, 40f);
			RectTransform val = (RectTransform)obj.transform;
			val.pivot = new Vector2(0f, 1f);
			val.anchoredPosition = new Vector2(x, 0f - y);
			((UnityEvent)obj.GetComponent<Button>().onClick).AddListener(onClick);
			return obj;
		}

		private static GameObject AddToggleRow(Transform parent, float colWidth, float labelW, string label, bool value, Action<bool> onChange, bool toggleOnLeft = false)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = NewRow(parent, colWidth, 34f);
			float num = (toggleOnLeft ? 0f : (labelW + 6f));
			float x = (toggleOnLeft ? 34f : 0f);
			AddText(val.transform, x, 0f, labelW, 34f, label, 15, (TextAnchor)3);
			GameObject obj = GUIManager.Instance.CreateToggle(val.transform, 26f, 26f);
			obj.transform.SetParent(val.transform, false);
			RectTransform val2 = (RectTransform)obj.transform;
			((Transform)val2).localScale = Vector3.one;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.anchoredPosition = new Vector2(num, -3f);
			Toggle component = obj.GetComponent<Toggle>();
			component.isOn = value;
			((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)delegate(bool b)
			{
				onChange(b);
			});
			return val;
		}

		private static GameObject AddScalingFeatureRow(Transform parent, float colWidth, float imgW, float imgH, Sprite sprite, string mainLabel, string description, bool mainValue, Action<bool> onMain, string subLabel, bool subValue, Action<bool> onSub)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: 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)
			float num = colWidth - imgW;
			GameObject val = NewRow(parent, colWidth, imgH);
			GameObject obj = NewUI("Image", val.transform, typeof(Image));
			RectTransform val2 = (RectTransform)obj.transform;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.sizeDelta = new Vector2(imgW, imgH);
			val2.anchoredPosition = new Vector2(colWidth - imgW, 0f);
			Image component = obj.GetComponent<Image>();
			component.sprite = sprite;
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			float num2 = 138f;
			float num3 = Mathf.Max(0f, (imgH - num2) * 0.5f);
			GameObject obj2 = GUIManager.Instance.CreateToggle(val.transform, 26f, 26f);
			obj2.transform.SetParent(val.transform, false);
			RectTransform val3 = (RectTransform)obj2.transform;
			((Transform)val3).localScale = Vector3.one;
			val3.anchorMin = new Vector2(0f, 1f);
			val3.anchorMax = new Vector2(0f, 1f);
			val3.pivot = new Vector2(0f, 1f);
			val3.anchoredPosition = new Vector2(0f, 0f - (num3 + 3f));
			Toggle component2 = obj2.GetComponent<Toggle>();
			component2.isOn = mainValue;
			((UnityEvent<bool>)(object)component2.onValueChanged).AddListener((UnityAction<bool>)delegate(bool b)
			{
				onMain(b);
			});
			float num4 = 34f;
			AddText(val.transform, num4, num3, num - num4 - 12f, 34f, mainLabel, 18, (TextAnchor)3, GUIManager.Instance.ValheimOrange);
			float num5 = num3 + 34f + 2f;
			AddText(val.transform, 0f, num5, num - 12f, 72f, description, 14, (TextAnchor)0, GUIManager.Instance.ValheimBeige);
			float num6 = num5 + 72f + 4f;
			GameObject obj3 = GUIManager.Instance.CreateToggle(val.transform, 22f, 22f);
			obj3.transform.SetParent(val.transform, false);
			RectTransform val4 = (RectTransform)obj3.transform;
			((Transform)val4).localScale = Vector3.one;
			val4.anchorMin = new Vector2(0f, 1f);
			val4.anchorMax = new Vector2(0f, 1f);
			val4.pivot = new Vector2(0f, 1f);
			val4.anchoredPosition = new Vector2(24f, 0f - (num6 + 2f));
			Toggle component3 = obj3.GetComponent<Toggle>();
			component3.isOn = subValue;
			((UnityEvent<bool>)(object)component3.onValueChanged).AddListener((UnityAction<bool>)delegate(bool b)
			{
				onSub(b);
			});
			float num7 = 54f;
			AddText(val.transform, num7, num6, num - num7 - 12f, 26f, subLabel, 14, (TextAnchor)3);
			return val;
		}

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

		private static GameObject AddEnumCycleRow(Transform parent, float colWidth, float labelW, float ctrlW, string label, string[] options, int currentIndex, Action<int> onChange)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			GameObject val = NewRow(parent, colWidth, 34f);
			AddText(val.transform, 0f, 0f, labelW, 34f, label, 15, (TextAnchor)3);
			int idx = Mathf.Clamp(currentIndex, 0, options.Length - 1);
			GameObject val2 = GUIManager.Instance.CreateButton(options[idx], val.transform, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(labelW + 6f, -2f), ctrlW, 28f);
			RectTransform val3 = (RectTransform)val2.transform;
			val3.pivot = new Vector2(0f, 1f);
			val3.anchoredPosition = new Vector2(labelW + 6f, -2f);
			Text bt = val2.GetComponentInChildren<Text>();
			((UnityEvent)val2.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				idx = (idx + 1) % options.Length;
				bt.text = options[idx];
				onChange(idx);
			});
			return val;
		}

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

		private static Slider BuildSlider(Transform parent, float x, float y, float width, float min, float max, float value, bool wholeNumbers)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Expected O, but got Unknown
			GameObject val = new GameObject("Slider", new Type[2]
			{
				typeof(RectTransform),
				typeof(Slider)
			})
			{
				layer = 5
			};
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(x, 0f - y);
			component.sizeDelta = new Vector2(width, 20f);
			GameObject obj = NewUI("Background", val.transform, typeof(Image));
			RectTransform val2 = (RectTransform)obj.transform;
			val2.anchorMin = new Vector2(0f, 0.25f);
			val2.anchorMax = new Vector2(1f, 0.75f);
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			((Graphic)obj.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.5f);
			GameObject val3 = NewUI("Fill Area", val.transform);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = new Vector2(0f, 0.25f);
			val4.anchorMax = new Vector2(1f, 0.75f);
			val4.offsetMin = new Vector2(5f, 0f);
			val4.offsetMax = new Vector2(-15f, 0f);
			RectTransform val5 = (RectTransform)NewUI("Fill", val3.transform, typeof(Image)).transform;
			val5.anchorMin = new Vector2(0f, 0f);
			val5.anchorMax = new Vector2(1f, 1f);
			val5.offsetMin = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			val5.sizeDelta = new Vector2(10f, 0f);
			GameObject val6 = NewUI("Handle Slide Area", val.transform);
			RectTransform val7 = (RectTransform)val6.transform;
			val7.anchorMin = new Vector2(0f, 0f);
			val7.anchorMax = new Vector2(1f, 1f);
			val7.offsetMin = new Vector2(10f, 0f);
			val7.offsetMax = new Vector2(-10f, 0f);
			GameObject val8 = NewUI("Handle", val6.transform, typeof(Image));
			((RectTransform)val8.transform).sizeDelta = new Vector2(20f, 0f);
			Image component2 = val8.GetComponent<Image>();
			component2.sprite = GUIManager.Instance.GetSprite("checkbox_marker");
			component2.type = (Type)1;
			((Graphic)component2).color = Color.white;
			Slider component3 = val.GetComponent<Slider>();
			component3.fillRect = val5;
			component3.handleRect = (RectTransform)val8.transform;
			((Selectable)component3).targetGraphic = (Graphic)(object)val8.GetComponent<Image>();
			component3.direction = (Direction)0;
			component3.minValue = min;
			component3.maxValue = max;
			component3.wholeNumbers = wholeNumbers;
			component3.value = value;
			GUIManager.Instance.ApplySliderStyle(component3);
			return component3;
		}

		private static GameObject NewUI(string name, Transform parent, params Type[] components)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			List<Type> list = new List<Type> { typeof(RectTransform) };
			if (components != null)
			{
				list.AddRange(components);
			}
			GameObject val = new GameObject(name, list.ToArray())
			{
				layer = 5
			};
			val.transform.SetParent(parent, false);
			return val;
		}
	}
	internal static class UIHudControl
	{
		public class StarLevelHud
		{
			public Dictionary<int, GameObject> Starlevel = new Dictionary<int, GameObject>();

			public Dictionary<int, Image> StarLevelFront = new Dictionary<int, Image>();

			public Dictionary<int, Image> StarLevelBack = new Dictionary<int, Image>();

			public bool IsBoss { get; set; }

			public string CreatureNameLocalized { get; set; }

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

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

			public string ModifierSource { get; set; }

			public Dictionary<string, DataObjects.ModifierType> CachedModifiers { get; set; }

			public GameObject StarLevelN { get; set; }

			public Image StarLevelNFrontImage { get; set; }

			public Image StarLevelNBackImage { get; set; }

			public Text StarLevelNText { get; set; }

			public HudData HudLink { get; set; }

			public TextMeshProUGUI HealthText { get; set; }

			public float NextResolveAttempt { get; set; }
		}

		internal static List<StarLevelHud> CurrentBossHuds = new List<StarLevelHud>();

		internal static Color StarColor = new Color(1f, 0.8174f, 0.3382f, 1f);

		private const float NotReadyRetryInterval = 0.5f;

		internal static bool BossHudConfigDirty = true;

		private static int lastBossHudCount = -1;

		public static Dictionary<ZDOID, StarLevelHud> characterExtendedHuds = new Dictionary<ZDOID, StarLevelHud>();

		private static GameObject HealthText;

		private static Sprite defaultStar;

		internal static GameObject BossHudRoot;

		internal static void SetDefaultStar()
		{
			defaultStar = Cache.GetPrefab<Sprite>("craft_icon");
		}

		internal static void RemoveExtendedHudFromCache(ZDOID id)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (characterExtendedHuds.ContainsKey(id))
			{
				StarLevelHud starLevelHud = characterExtendedHuds[id];
				if ((Object)(object)starLevelHud.HealthText != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)starLevelHud.HealthText).gameObject);
				}
				if (starLevelHud.IsBoss)
				{
					CurrentBossHuds.Remove(starLevelHud);
				}
				characterExtendedHuds.Remove(id);
			}
		}

		private static Dictionary<string, DataObjects.ModifierType> GetModifiersCached(StarLevelHud hud, Character chara)
		{
			if ((Object)(object)chara == (Object)null || (Object)(object)chara.m_nview == (Object)null || chara.m_nview.GetZDO() == null)
			{
				return null;
			}
			string text = chara.m_nview.GetZDO().GetString(DataObjects.SLS_MODSV2, (string)null);
			if (hud != null && hud.CachedModifiers != null && hud.ModifierSource == text)
			{
				return hud.CachedModifiers;
			}
			Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(chara);
			if (hud != null)
			{
				hud.ModifierSource = text;
				hud.CachedModifiers = creatureModifiers;
			}
			return creatureModifiers;
		}

		public static void InvalidateCacheEntry(Character chara)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)chara == (Object)null || chara.GetZDOID() == ZDOID.None)
			{
				return;
			}
			ZDOID zDOID = chara.GetZDOID();
			if (!characterExtendedHuds.ContainsKey(zDOID))
			{
				return;
			}
			StarLevelHud starLevelHud = characterExtendedHuds[zDOID];
			DataObjects.CharacterCacheEntry characterCacheEntry = CompositeLazyCache.GetCacheEntry(zDOID);
			if (characterCacheEntry == null)
			{
				characterCacheEntry = CompositeLazyCache.GetAndSetLocalCache(chara);
				if (characterCacheEntry == null || CompositeLazyCache.GetCacheEntry(zDOID) == null)
				{
					starLevelHud.NextResolveAttempt = Time.time + 0.5f;
					return;
				}
			}
			Dictionary<string, DataObjects.ModifierType> dictionary = (characterCacheEntry.CreatureModifiers = GetModifiersCached(starLevelHud, starLevelHud.HudLink.m_character));
			characterCacheEntry.CreatureNameLocalizable = CreatureModifiers.BuildCreatureLocalizableName(starLevelHud.HudLink.m_character, dictionary);
			starLevelHud.Level = chara.GetLevel();
			UpdateHudModifiers(zDOID, starLevelHud, dictionary);
		}

		internal static void StarLevelHudDisplay(GameObject star, Transform baseHud, Transform bossHud)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Expected O, but got Unknown
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Expected O, but got Unknown
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			SetupStar(star, 2, baseHud);
			SetupStar(star, 3, baseHud);
			SetupStar(star, 4, baseHud);
			SetupStar(star, 5, baseHud);
			SetupStar(star, 6, baseHud);
			GameObject val = new GameObject("SLS_level_n");
			val.transform.SetParent(baseHud);
			GameObject obj = Object.Instantiate<GameObject>(star, val.transform);
			val.transform.localPosition = new Vector3(-42f, 19f, 0f);
			obj.transform.localPosition = new Vector3(0f, 0f, 0f);
			GameObject val2 = Object.Instantiate<GameObject>(new GameObject("level_n_name"), val.transform);
			val2.transform.SetParent(val.transform);
			val2.transform.localPosition = new Vector3(0f, 0f, 0f);
			GUIManager.Instance.CreateText("999", val2.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(185f, -13f), GUIManager.Instance.AveriaSerifBold, 14, GUIManager.Instance.ValheimYellow, true, Color.black, 350f, 40f, false);
			val.SetActive(false);
			SetupStar(star, 2, bossHud, boss: true);
			SetupStar(star, 3, bossHud, boss: true);
			SetupStar(star, 4, bossHud, boss: true);
			SetupStar(star, 5, bossHud, boss: true);
			SetupStar(star, 6, bossHud, boss: true);
			GameObject val3 = new GameObject("SLS_level_n");
			val3.transform.SetParent(bossHud);
			GameObject obj2 = Object.Instantiate<GameObject>(star, val3.transform);
			obj2.GetComponent<RectTransform>().sizeDelta = new Vector2(20f, 20f);
			((Component)obj2.transform.Find("star (1)")).gameObject.GetComponent<RectTransform>().sizeDelta = new Vector2(16f, 16f);
			val3.transform.localPosition = new Vector3(-17f, -6f, 0f);
			obj2.transform.localPosition = new Vector3(0f, 0f, 0f);
			GameObject val4 = Object.Instantiate<GameObject>(new GameObject("level_n_name"), val3.transform);
			val4.transform.SetParent(val3.transform);
			val4.transform.localPosition = new Vector3(0f, 0f, 0f);
			GUIManager.Instance.CreateText("999", val4.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(185f, -7f), GUIManager.Instance.AveriaSerifBold, 23, GUIManager.Instance.ValheimYellow, true, Color.black, 350f, 40f, false);
			val3.SetActive(false);
		}

		private static void SetupStar(GameObject star, int level, Transform parent_t, bool boss = false)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_005d: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"SLS_level_{level}");
			val.transform.SetParent(parent_t);
			GameObject val2 = Object.Instantiate<GameObject>(star, val.transform);
			if (boss)
			{
				RectTransform component = ((Component)val2.transform.Find("star (1)")).gameObject.GetComponent<RectTransform>();
				RectTransform component2 = val2.GetComponent<RectTransform>();
				component.sizeDelta = new Vector2(16f, 16f);
				component2.sizeDelta = new Vector2(20f, 20f);
			}
			val.SetActive(false);
			switch (level)
			{
			case 2:
				if (boss)
				{
					val.transform.localPosition = new Vector3(0f, -6f, 0f);
					break;
				}
				val.transform.localPosition = new Vector3(-41f, 19f, 0f);
				val2.transform.localPosition = new Vector3(0f, 0f, 0f);
				break;
			case 3:
				if (boss)
				{
					val.transform.localPosition = new Vector3(-20f, -6f, 0f);
					break;
				}
				val.transform.localPosition = new Vector3(-25f, 19f, 0f);
				val2.transform.localPosition = new Vector3(0f, 0f, 0f);
				break;
			case 4:
				if (boss)
				{
					val.transform.localPosition = new Vector3(20f, -6f, 0f);
					val2.transform.localPosition = new Vector3(0f, 0f, 0f);
				}
				else
				{
					val.transform.localPosition = new Vector3(-9f, 19f, 0f);
					val2.transform.localPosition = new Vector3(0f, 0f, 0f);
				}
				break;
			case 5:
				if (boss)
				{
					val.transform.localPosition = new Vector3(-40f, -6f, 0f);
					val2.transform.localPosition = new Vector3(0f, 0f, 0f);
				}
				else
				{
					val.transform.localPosition = new Vector3(7f, 19f, 0f);
					val2.transform.localPosition = new Vector3(0f, 0f, 0f);
				}
				break;
			case 6:
				if (boss)
				{
					val.transform.localPosition = new Vector3(40f, -6f, 0f);
					val2.transform.localPosition = new Vector3(0f, 0f, 0f);
				}
				else
				{
					val.transform.localPosition = new Vector3(23f, 19f, 0f);
					val2.transform.localPosition = new Vector3(0f, 0f, 0f);
				}
				break;
			}
		}

		private static void UpdateHealthText(StarLevelHud hud, Character chara)
		{
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			if (hud == null || (Object)(object)chara == (Object)null || hud.HudLink == null || (Object)(object)hud.HudLink.m_gui == (Object)null)
			{
				return;
			}
			if (!ValConfig.EnableEnemyHealthbarNumberDisplay.Value)
			{
				if ((Object)(object)hud.HealthText != (Object)null)
				{
					((Component)hud.HealthText).gameObject.SetActive(false);
				}
				return;
			}
			if ((Object)(object)hud.HealthText == (Object)null)
			{
				Transform val = hud.HudLink.m_gui.transform.Find("Health");
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if ((Object)(object)HealthText == (Object)null)
				{
					LoadAssets();
				}
				GameObject val2 = Object.Instantiate<GameObject>(HealthText, val);
				hud.HealthText = val2.GetComponent<TextMeshProUGUI>();
				if ((Object)(object)hud.HealthText == (Object)null)
				{
					return;
				}
				((TMP_Text)hud.HealthText).fontSize = 10f * (ValConfig.EnemyHealthbarScalarY.Value * ValConfig.HealthDisplayFontSizeAdjustment.Value);
				if (!ValConfig.UseCustomHealthFont.Value)
				{
					((TMP_Text)hud.HealthText).font = ((TMP_Text)hud.HudLink.m_name).font;
				}
				if (hud.IsBoss)
				{
					Transform transform = val2.transform;
					((transform is RectTransform) ? transform : null).localPosition = new Vector3(0f, 4f, 0f);
					((TMP_Text)hud.HealthText).fontSize = 20f;
					((TMP_Text)hud.HealthText).characterSpacing = 12f;
				}
			}
			if (!((Component)hud.HealthText).gameObject.activeSelf)
			{
				((Component)hud.HealthText).gameObject.SetActive(true);
			}
			((TMP_Text)hud.HealthText).text = $"{chara.GetHealth():N0}/{chara.GetMaxHealth():N0}";
		}

		public static void UpdateHudForAllLevels(HudData ehud)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			if (ehud == null || (Object)(object)ehud.m_character == (Object)null || ehud.m_character.IsPlayer())
			{
				return;
			}
			int level = ehud.m_character.GetLevel();
			ZDOID zDOID = ehud.m_character.GetZDOID();
			if (zDOID == ZDOID.None)
			{
				return;
			}
			StarLevelHud starLevelHud = new StarLevelHud
			{
				Level = level
			};
			characterExtendedHuds.TryGetValue(zDOID, out var value);
			Dictionary<string, DataObjects.ModifierType> dictionary = GetModifiersCached(value, ehud.m_character);
			if (dictionary == null)
			{
				dictionary = new Dictionary<string, DataObjects.ModifierType>();
			}
			if (characterExtendedHuds.ContainsKey(zDOID))
			{
				starLevelHud = characterExtendedHuds[zDOID];
				if (starLevelHud == null || (starLevelHud.Starlevel.ContainsKey(3) && (Object)(object)starLevelHud.Starlevel[3] == (Object)null))
				{
					Logger.LogDebug($"UI Cache Invalid for {zDOID}, removing.");
					RemoveExtendedHudFromCache(zDOID);
					return;
				}
				UpdateHealthText(starLevelHud, ehud.m_character);
				List<string> listA = dictionary.Keys.ToList();
				DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(zDOID);
				int level2 = ehud.m_character.GetLevel();
				if (!listA.CompareListContents(starLevelHud.DisplayedMods) || cacheEntry == null || level2 != starLevelHud.Level)
				{
					if (!(Time.time < starLevelHud.NextResolveAttempt))
					{
						starLevelHud.NextResolveAttempt = Time.time + 0.5f;
						if (ValConfig.EnableDebugMode.Value)
						{
							Logger.LogDebug($"UI Cache for {zDOID} outdated (level {level2}-{starLevelHud.Level} or mods {starLevelHud.DisplayedMods.Count}-{dictionary.Count} or name {((TMP_Text)starLevelHud.HudLink.m_name).text}-{starLevelHud.CreatureNameLocalized}), updating cache.");
						}
						CompositeLazyCache.ClearCachedCreature(ehud.m_character);
						InvalidateCacheEntry(ehud.m_character);
					}
					return;
				}
				((TMP_Text)starLevelHud.HudLink.m_name).text = starLevelHud.CreatureNameLocalized;
			}
			else
			{
				starLevelHud.HudLink = ehud;
				Logger.LogDebug($"Creating new hud for {ehud.m_character} with level {level}");
				starLevelHud.IsBoss = ehud.m_character.IsBoss();
				if (starLevelHud.IsBoss)
				{
					CurrentBossHuds.Add(starLevelHud);
				}
				if ((ValConfig.EnemyHealthbarScalarX.Value != 1f || ValConfig.EnemyHealthbarScalarY.Value != 1f) && !starLevelHud.IsBoss)
				{
					RectTransform component = ((Component)ehud.m_gui.transform.Find("Health")).GetComponent<RectTransform>();
					Vector2 val = default(Vector2);
					((Vector2)(ref val))..ctor(100f * ValConfig.EnemyHealthbarScalarX.Value, 5f * ValConfig.EnemyHealthbarScalarY.Value);
					component.sizeDelta = val;
					RectTransform component2 = ((Component)((Transform)component).Find("health_slow")).GetComponent<RectTransform>();
					((Component)component2).GetComponent<GuiBar>().m_width = val.x;
					((Component)((Transform)component2).Find("bar")).GetComponent<RectTransform>().sizeDelta = val;
					RectTransform component3 = ((Component)((Transform)component).Find("health_fast")).GetComponent<RectTransform>();
					RectTransform component4 = ((Component)((Transform)component3).Find("bar")).GetComponent<RectTransform>();
					((Component)component3).GetComponent<GuiBar>().m_width = val.x;
					component4.sizeDelta = val;
				}
				UpdateHealthText(starLevelHud, ehud.m_character);
				UpdateHudModifiers(zDOID, starLevelHud, dictionary);
				characterExtendedHuds.Add(zDOID, starLevelHud);
			}
			if (level <= 6)
			{
				switch (level)
				{
				case 2:
					starLevelHud.Starlevel[2].SetActive(true);
					starLevelHud.Starlevel[3].SetActive(false);
					starLevelHud.Starlevel[4].SetActive(false);
					starLevelHud.Starlevel[5].SetActive(false);
					starLevelHud.Starlevel[6].SetActive(false);
					break;
				case 3:
					starLevelHud.Starlevel[2].SetActive(true);
					starLevelHud.Starlevel[3].SetActive(true);
					starLevelHud.Starlevel[4].SetActive(false);
					starLevelHud.Starlevel[5].SetActive(false);
					starLevelHud.Starlevel[6].SetActive(false);
					break;
				case 4:
					starLevelHud.Starlevel[2].SetActive(true);
					starLevelHud.Starlevel[3].SetActive(true);
					starLevelHud.Starlevel[4].SetActive(true);
					starLevelHud.Starlevel[5].SetActive(false);
					starLevelHud.Starlevel[6].SetActive(false);
					break;
				case 5:
					starLevelHud.Starlevel[2].SetActive(true);
					starLevelHud.Starlevel[3].SetActive(true);
					starLevelHud.Starlevel[4].SetActive(true);
					starLevelHud.Starlevel[5].SetActive(true);
					starLevelHud.Starlevel[6].SetActive(false);
					break;
				case 6:
					starLevelHud.Starlevel[2].SetActive(true);
					starLevelHud.Starlevel[3].SetActive(true);
					starLevelHud.Starlevel[4].SetActive(true);
					starLevelHud.Starlevel[5].SetActive(true);
					starLevelHud.Starlevel[6].SetActive(true);
					break;
				}
			}
			else
			{
				starLevelHud.Starlevel[2].SetActive(false);
				starLevelHud.Starlevel[3].SetActive(false);
				starLevelHud.Starlevel[4].SetActive(false);
				starLevelHud.Starlevel[5].SetActive(false);
				starLevelHud.Starlevel[6].SetActive(false);
			}
			if (level > 6)
			{
				starLevelHud.StarLevelN.SetActive(true);
				starLevelHud.StarLevelNText.text = (level - 1).ToString();
			}
			else
			{
				starLevelHud.StarLevelN.SetActive(false);
			}
		}

		public static void UpdateHudModifiers(ZDOID zdoid, StarLevelHud extended_hud, Dictionary<string, DataObjects.ModifierType> mods)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			if (extended_hud.HudLink == null || (Object)(object)extended_hud.HudLink.m_gui == (Object)null)
			{
				RemoveExtendedHudFromCache(zdoid);
				return;
			}
			if (mods == null)
			{
				mods = new Dictionary<string, DataObjects.ModifierType>();
			}
			DataObjects.CharacterCacheEntry characterCacheEntry = CompositeLazyCache.GetCacheEntry(extended_hud.HudLink.m_character);
			if (characterCacheEntry != null && (characterCacheEntry.CreatureModifiers == null || !characterCacheEntry.CreatureModifiers.Keys.ToList().CompareListContents(mods.Keys.ToList())))
			{
				CompositeLazyCache.ClearCachedCreature(extended_hud.HudLink.m_character);
				characterCacheEntry = CompositeLazyCache.GetAndSetLocalCache(extended_hud.HudLink.m_character);
			}
			if (characterCacheEntry != null)
			{
				extended_hud.CreatureNameLocalized = extended_hud.HudLink.m_character.m_nview.GetZDO().GetString(ZDOVars.s_tamedName, Localization.instance.Localize(characterCacheEntry.CreatureNameLocalizable));
				((TMP_Text)extended_hud.HudLink.m_name).text = extended_hud.CreatureNameLocalized;
			}
			Dictionary<int, Sprite> dictionary = new Dictionary<int, Sprite>();
			int num = 2;
			extended_hud.DisplayedMods = mods.Keys.ToList();
			if (CreatureModifiersData.SelectedModifierDisplayStyle != DataObjects.ModifierDisplayStyle.None)
			{
				foreach (KeyValuePair<string, DataObjects.ModifierType> mod in mods)
				{
					if (!(mod.Key == CreatureModifiers.NoMods))
					{
						DataObjects.CreatureModifierDefinition creatureModifierDefinition = CreatureModifiersData.ModifierDefinitions[mod.Key];
						if (creatureModifierDefinition.StarVisual != null && CreatureModifiersData.LoadedModifierSprites.ContainsKey(creatureModifierDefinition.StarVisual))
						{
							Sprite value = CreatureModifiersData.LoadedModifierSprites[creatureModifierDefinition.StarVisual];
							dictionary.Add(num, value);
						}
						num++;
					}
				}
			}
			for (int i = 2; i < 7; i++)
			{
				if (!extended_hud.Starlevel.ContainsKey(i))
				{
					extended_hud.Starlevel.Add(i, ((Component)extended_hud.HudLink.m_gui.transform.Find($"SLS_level_{i}")).gameObject);
				}
				if (!extended_hud.StarLevelBack.ContainsKey(i))
				{
					extended_hud.StarLevelBack.Add(i, ((Component)extended_hud.HudLink.m_gui.transform.Find($"SLS_level_{i}/star(Clone)")).gameObject.GetComponent<Image>());
				}
				if (!extended_hud.StarLevelFront.ContainsKey(i))
				{
					extended_hud.StarLevelFront.Add(i, ((Component)extended_hud.HudLink.m_gui.transform.Find($"SLS_level_{i}/star(Clone)/star (1)")).gameObject.GetComponent<Image>());
				}
				if (dictionary.ContainsKey(i))
				{
					if ((Object)(object)extended_hud.StarLevelFront[i] != (Object)null)
					{
						extended_hud.StarLevelFront[i].sprite = dictionary[i];
						((Graphic)extended_hud.StarLevelFront[i]).rectTransform.sizeDelta = new Vector2(17f, 17f);
						((Graphic)extended_hud.StarLevelFront[i]).color = Color.white;
					}
					if ((Object)(object)extended_hud.StarLevelBack[i] != (Object)null)
					{
						extended_hud.StarLevelBack[i].sprite = dictionary[i];
						((Graphic)extended_hud.StarLevelBack[i]).rectTransform.sizeDelta = new Vector2(21f, 21f);
					}
				}
				else
				{
					if ((Object)(object)extended_hud.StarLevelFront[i] != (Object)null)
					{
						extended_hud.StarLevelFront[i].sprite = defaultStar;
						((Graphic)extended_hud.StarLevelFront[i]).rectTransform.sizeDelta = new Vector2(14f, 14f);
						((Graphic)extended_hud.StarLevelFront[i]).color = StarColor;
					}
					if ((Object)(object)extended_hud.StarLevelBack[i] != (Object)null)
					{
						extended_hud.StarLevelBack[i].sprite = defaultStar;
						((Graphic)extended_hud.StarLevelBack[i]).rectTransform.sizeDelta = new Vector2(16f, 16f);
					}
				}
			}
			extended_hud.StarLevelN = ((Component)extended_hud.HudLink.m_gui.transform.Find("SLS_level_n")).gameObject;
			extended_hud.StarLevelNBackImage = ((Component)extended_hud.HudLink.m_gui.transform.Find("SLS_level_n/star(Clone)")).gameObject.GetComponent<Image>();
			extended_hud.StarLevelNFrontImage = ((Component)extended_hud.HudLink.m_gui.transform.Find("SLS_level_n/star(Clone)/star (1)")).gameObject.GetComponent<Image>();
			extended_hud.StarLevelNText = ((Component)extended_hud.HudLink.m_gui.transform.Find("SLS_level_n/level_n_name(Clone)/Text")).gameObject.GetComponent<Text>();
			if (dictionary.Count > 0)
			{
				extended_hud.StarLevelNFrontImage.sprite = dictionary.First().Value;
				((Graphic)extended_hud.StarLevelNFrontImage).rectTransform.sizeDelta = new Vector2(17f, 17f);
				extended_hud.StarLevelNBackImage.sprite = dictionary.First().Value;
				((Graphic)extended_hud.StarLevelNBackImage).rectTransform.sizeDelta = new Vector2(21f, 21f);
			}
			else
			{
				extended_hud.StarLevelNFrontImage.sprite = defaultStar;
				((Graphic)extended_hud.StarLevelNFrontImage).rectTransform.sizeDelta = new Vector2(17f, 17f);
				extended_hud.StarLevelNBackImage.sprite = defaultStar;
				((Graphic)extended_hud.StarLevelNBackImage).rectTransform.sizeDelta = new Vector2(21f, 21f);
			}
		}

		public static void OnBossHudConfigChanged(object s, EventArgs e)
		{
			BossHudConfigDirty = true;
		}

		internal static float GetHudScaleFactor(EnemyHud hud)
		{
			Canvas val = (((Object)(object)hud != (Object)null) ? ((Component)hud).GetComponentInParent<Canvas>() : null);
			float num = (((Object)(object)val != (Object)null && (Object)(object)val.rootCanvas != (Object)null) ? val.rootCanvas.scaleFactor : 0f);
			if (num <= 0f)
			{
				num = Mathf.Min((float)Screen.width / 1920f, (float)Screen.height / 1080f) * PlatformPrefs.GetFloat("GuiScale", 1f);
			}
			if (!(num <= 0f))
			{
				return num;
			}
			return 1f;
		}

		internal static HorizontalOrVerticalLayoutGroup EnsureBossLayoutGroup(bool stack)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			if ((Object)(object)BossHudRoot == (Object)null)
			{
				return null;
			}
			HorizontalOrVerticalLayoutGroup val = BossHudRoot.GetComponent<HorizontalOrVerticalLayoutGroup>();
			if ((Object)(object)val == (Object)null || (stack && val is HorizontalLayoutGroup) || (!stack && val is VerticalLayoutGroup))
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)val);
				}
				val = (HorizontalOrVerticalLayoutGroup)(stack ? ((object)BossHudRoot.AddComponent<VerticalLayoutGroup>()) : ((object)BossHudRoot.AddComponent<HorizontalLayoutGroup>()));
			}
			((LayoutGroup)val).childAlignment = (TextAnchor)1;
			val.childForceExpandHeight = false;
			val.spacing = ValConfig.BossHealthbarSpacing.Value;
			((LayoutGroup)val).padding = new RectOffset(0, 0, ValConfig.BossHudTopBuffer.Value, 0);
			if (stack)
			{
				val.childControlWidth = false;
				val.childForceExpandWidth = false;
				val.childControlHeight = true;
			}
			else
			{
				val.childControlWidth = true;
				val.childForceExpandWidth = true;
				val.childControlHeight = false;
			}
			return val;
		}

		internal static void SetBossBarWidth(GameObject bossGui, float width)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)bossGui == (Object)null)
			{
				return;
			}
			LayoutElement component = bossGui.GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.minWidth = width;
				component.preferredWidth = width;
			}
			Transform obj = bossGui.transform.Find("Name");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if (val != null)
			{
				val.sizeDelta = new Vector2(width, 40f);
			}
			Transform val2 = bossGui.transform.Find("Health");
			if (!((Object)(object)val2 == (Object)null))
			{
				SetBossHealthBar(val2.Find("health_slow"), width);
				SetBossHealthBar(val2.Find("health_fast"), width);
				Transform obj2 = val2.Find("Background/bkg");
				RectTransform val3 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
				if (val3 != null)
				{
					val3.sizeDelta = new Vector2(width, 20f);
				}
				Transform obj3 = val2.Find("Background/darken");
				RectTransform val4 = (RectTransform)(object)((obj3 is RectTransform) ? obj3 : null);
				if (val4 != null)
				{
					val4.sizeDelta = new Vector2(width, 24f);
				}
			}
		}

		private static void SetBossHealthBar(Transform healthBar, float width)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)healthBar == (Object)null))
			{
				Transform obj = healthBar.Find("bar");
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if (val != null)
				{
					val.sizeDelta = new Vector2(width, 20f);
					((Transform)val).localPosition = Vector2.op_Implicit(new Vector2(width * -0.5f, 0f));
				}
				GuiBar component = ((Component)healthBar).GetComponent<GuiBar>();
				if ((Object)(object)component != (Object)null)
				{
					component.SetWidth(width);
				}
			}
		}

		internal static void StackBossHuds(EnemyHud instance)
		{
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)instance == (Object)null || (Object)(object)BossHudRoot == (Object)null)
			{
				return;
			}
			int num = 0;
			foreach (KeyValuePair<Character, HudData> hud in instance.m_huds)
			{
				HudData value = hud.Value;
				if (value != null && (Object)(object)value.m_character != (Object)null && value.m_character.IsBoss() && (Object)(object)value.m_gui != (Object)null && value.m_gui.activeSelf)
				{
					num++;
				}
			}
			if (!BossHudConfigDirty && num == lastBossHudCount)
			{
				return;
			}
			BossHudConfigDirty = false;
			lastBossHudCount = num;
			bool value2 = ValConfig.StackMultipleBossHealthbars.Value;
			EnsureBossLayoutGroup(value2);
			float num2 = (float)Screen.width / GetHudScaleFactor(instance) * ValConfig.BossHealthbarWidthPercent.Value;
			RectTransform component = BossHudRoot.GetComponent<RectTransform>();
			float width = num2;
			if (!value2)
			{
				int num3 = Mathf.Max(1, num);
				float value3 = ValConfig.BossHealthbarSpacing.Value;
				width = Mathf.Max(1f, (num2 - value3 * (float)(num3 - 1)) / (float)num3);
				if ((Object)(object)component != (Object)null)
				{
					component.sizeDelta = new Vector2(num2, component.sizeDelta.y);
				}
			}
			else if ((Object)(object)component != (Object)null)
			{
				component.sizeDelta = new Vector2(0f, component.sizeDelta.y);
			}
			if ((Object)(object)instance.m_baseHudBoss != (Object)null)
			{
				SetBossBarWidth(instance.m_baseHudBoss, width);
			}
			foreach (KeyValuePair<Character, HudData> hud2 in instance.m_huds)
			{
				HudData value4 = hud2.Value;
				if (value4 != null && (Object)(object)value4.m_character != (Object)null && value4.m_character.IsBoss() && (Object)(object)value4.m_gui != (Object)null)
				{
					SetBossBarWidth(value4.m_gui, width);
				}
			}
		}

		internal static void LoadAssets()
		{
			HealthText = StarLevelSystem.EmbeddedResourceBundle.LoadAsset<GameObject>("HealthText.prefab");
		}
	}
	internal static class UIPatches
	{
		[HarmonyPatch(typeof(EnemyHud), "Awake")]
		public static class EnableLevelDisplay
		{
			public static void Postfix(EnemyHud __instance)
			{
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Expected O, but got Unknown
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_0191: Expected O, but got Unknown
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Expected O, but got Unknown
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				GameObject gameObject = ((Component)__instance.m_baseHud.transform.Find("level_2/star")).gameObject;
				((Component)__instance.m_baseHud.transform.Find("level_3/star")).gameObject.SetActive(false);
				UIHudControl.StarLevelHudDisplay(gameObject, __instance.m_baseHud.transform, __instance.m_baseHudBoss.transform);
				Logger.LogDebug("Setting BossHud root");
				UIHudControl.BossHudRoot = Object.Instantiate<GameObject>(new GameObject("BossHuds"), ((Component)((Component)__instance).transform.Find("HudRoot")).transform);
				((Object)UIHudControl.BossHudRoot).name = "BossHuds";
				UIHudControl.EnsureBossLayoutGroup(ValConfig.StackMultipleBossHealthbars.Value);
				RectTransform component = UIHudControl.BossHudRoot.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					Vector2 val = default(Vector2);
					((Vector2)(ref val))..ctor(0.5f, 1f);
					component.pivot = val;
					Vector2 anchorMin = (component.anchorMax = val);
					component.anchorMin = anchorMin;
					component.anchoredPosition = Vector2.zero;
				}
				Logger.LogDebug("Setting root layout element");
				if ((Object)(object)__instance.m_baseHudBoss.GetComponent<LayoutElement>() == (Object)null)
				{
					__instance.m_baseHudBoss.AddComponent<LayoutElement>().minHeight = 50f;
				}
				Logger.LogDebug("Modifying name position");
				((Transform)(RectTransform)__instance.m_baseHudBoss.transform.Find("Name")).localPosition = new Vector3(0f, 42f, 0f);
				Logger.LogDebug("Building boss health bar background container");
				Transform val3 = __instance.m_baseHudBoss.transform.Find("Health");
				GameObject val4 = Object.Instantiate<GameObject>(new GameObject("Background"), val3);
				((Object)val4).name = "Background";
				RectTransform val5 = (RectTransform)((Component)val3.Find("bkg")).transform;
				RectTransform val6 = (RectTransform)((Component)val3.Find("darken")).transform;
				((Transform)val5).SetParent(val4.transform, false);
				((Transform)val6).SetParent(val4.transform, false);
				val4.transform.SetSiblingIndex(0);
				float width = (float)Screen.width / UIHudControl.GetHudScaleFactor(__instance) * ValConfig.BossHealthbarWidthPercent.Value;
				UIHudControl.SetBossBarWidth(__instance.m_baseHudBoss, width);
				UIHudControl.BossHudConfigDirty = true;
			}
		}

		[HarmonyPatch(typeof(EnemyHud), "UpdateHuds")]
		public static class StackBossHealthbars
		{
			public static void Postfix(EnemyHud __instance)
			{
				UIHudControl.StackBossHuds(__instance);
			}
		}

		[HarmonyPatch(typeof(Tameable), "SetName")]
		public static class UpdateTamedName
		{
			public static void Postfix(Tameable __instance)
			{
				UIHudControl.InvalidateCacheEntry(__instance.m_character);
			}
		}

		[HarmonyPatch(typeof(EnemyHud), "ShowHud")]
		public static class DisableVanillaStarsByDefault
		{
			public static void Postfix(EnemyHud __instance, Character c)
			{
				if ((Object)(object)__instance == (Object)null || (Object)(object)c == (Object)null)
				{
					return;
				}
				__instance.m_huds.TryGetValue(c, out var value);
				if (!c.IsBoss())
				{
					if (value == null || (Object)(object)value.m_level2 == (Object)null || (Object)(object)value.m_level3 == (Object)null)
					{
						return;
					}
					RectTransform level = value.m_level2;
					if (level != null)
					{
						GameObject gameObject = ((Component)level).gameObject;
						if (gameObject != null)
						{
							gameObject.SetActive(false);
						}
					}
					RectTransform level2 = value.m_level3;
					if (level2 != null)
					{
						GameObject gameObject2 = ((Component)level2).gameObject;
						if (gameObject2 != null)
						{
							gameObject2.SetActive(false);
						}
					}
				}
				else
				{
					value.m_gui.transform.SetParent(UIHudControl.BossHudRoot.transform, false);
				}
			}
		}

		[HarmonyPatch(typeof(EnemyHud))]
		public static class SetupCreatureLevelDisplay
		{
			[HarmonyTranspiler]
			[HarmonyPatch("UpdateHuds")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Expected O, but got Unknown
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Expected O, but got Unknown
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Expected O, but got Unknown
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Expected O, but got Unknown
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[8]
				{
					new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Stloc_S, (object)null, (string)null)
				}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldloc_S, (object)(byte)6),
					Transpilers.EmitDelegate<Action<HudData>>((Action<HudData>)UIHudControl.UpdateHudForAllLevels)
				}).RemoveInstructions(23)
					.ThrowIfNotMatch("Unable to patch Enemy Hud update, levels will not be displayed properly.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}
		}

		[HarmonyPatch(typeof(Character), "GetHoverName")]
		public static class DisplayCreatureNameChanges
		{
			public static bool Prefix(Character __instance, ref string __result)
			{
				DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(__instance);
				if (cacheEntry == null || cacheEntry.CreatureNameLocalizable == null)
				{
					return true;
				}
				__result = Localization.instance.Localize(cacheEntry.CreatureNameLocalizable);
				Tameable component = ((Component)__instance).gameObject.GetComponent<Tameable>();
				if (Object.op_Implicit((Object)(object)component) && __instance.IsTamed())
				{
					__result = component.m_nview.GetZDO().GetString(ZDOVars.s_tamedName, __result);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Menu), "Start")]
		public static class AddPauseMenuButton
		{
			public static void Postfix(Menu __instance)
			{
				QuickConfigureTool.CreatePauseMenuButton(__instance);
			}
		}
	}
}
namespace StarLevelSystem.modules.Sizes
{
	internal static class SizeModifications
	{
		private static readonly Dictionary<string, Vector3> SizeEstimateCache = new Dictionary<string, Vector3>();

		internal static bool ForceUpdateSize = false;

		internal static float DetermineScaleMultiplier(DataObjects.CharacterCacheEntry characterCache, float bonus = 0f)
		{
			int num = Mathf.Max(0, characterCache.Level - 1);
			float num2 = (ValConfig.EnableCreatureScalingPerLevel.Value ? (characterCache.CreaturePerLevelValueModifiers[DataObjects.CreaturePerLevelAttribute.SizePerLevel] * (float)num) : 0f);
			float num3 = bonus + characterCache.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.Size] + num2;
			return Mathf.Max(ValConfig.MinimumCreatureScale.Value, num3);
		}

		internal static void SetSizeModification(GameObject obj, ZNetView zview, DataObjects.CharacterCacheEntry characterCache, bool update = false, float bonus = 0f)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Vector3 vec = zview.m_zdo.GetVec3(DataObjects.SLS_SIZE, Vector3.zero);
			if (!update && !ForceUpdateSize && vec != Vector3.zero)
			{
				obj.transform.localScale = vec;
				UpdateRidingCreaturesForSizeScaling(obj, characterCache);
				Physics.SyncTransforms();
			}
			else if (ValConfig.EnableScalingInDungeons.Value || !Character.InInterior(obj.transform.position))
			{
				float num = DetermineScaleMultiplier(characterCache, bonus);
				Vector3 val = GetSizeReferenceForObject(((Object)obj).name) * num;
				obj.transform.localScale = val;
				UpdateRidingCreaturesForSizeScaling(obj, characterCache);
				zview.m_zdo.Set(DataObjects.SLS_SIZE, val);
				Physics.SyncTransforms();
			}
		}

		internal static Vector3 GetSizeReferenceForObject(string name)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			string prefabName = Utils.GetPrefabName(name);
			Vector3 val;
			if (SizeEstimateCache.ContainsKey(prefabName))
			{
				val = SizeEstimateCache[prefabName];
			}
			else
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab(prefabName);
				if ((Object)(object)prefab == (Object)null)
				{
					Logger.LogWarning("No prefab found for '" + prefabName + "', assuming a reference scale of 1.");
					val = Vector3.one;
				}
				else
				{
					val = prefab.transform.localScale;
				}
				SizeEstimateCache.Add(prefabName, val);
			}
			return val;
		}

		internal static void PrepareSizeRefCache()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			string clone = "(Clone)";
			foreach (Character item in (from obj in Resources.FindObjectsOfTypeAll<Character>()
				where !((Object)obj).name.EndsWith(clone)
				select obj).ToList())
			{
				if (!SizeEstimateCache.ContainsKey(((Object)item).name))
				{
					SizeEstimateCache.Add(((Object)item).name, ((Component)item).transform.localScale);
				}
			}
			foreach (Humanoid item2 in (from obj in Resources.FindObjectsOfTypeAll<Humanoid>()
				where !((Object)obj).name.EndsWith(clone)
				select obj).ToList())
			{
				if (!SizeEstimateCache.ContainsKey(((Object)item2).name))
				{
					SizeEstimateCache.Add(((Object)item2).name, ((Component)item2).transform.localScale);
				}
			}
			foreach (GameObject item3 in ObjectDB.m_instance.m_items)
			{
				if (!SizeEstimateCache.ContainsKey(((Object)item3).name))
				{
					SizeEstimateCache.Add(((Object)item3).name, item3.transform.localScale);
				}
			}
			foreach (Ragdoll item4 in (from obj in Resources.FindObjectsOfTypeAll<Ragdoll>()
				where !((Object)obj).name.EndsWith(clone)
				select obj).ToList())
			{
				if (!SizeEstimateCache.ContainsKey(((Object)item4).name))
				{
					SizeEstimateCache.Add(((Object)item4).name, ((Component)item4).transform.localScale);
				}
			}
		}

		internal static void UpdateRidingCreaturesForSizeScaling(GameObject creature, DataObjects.CharacterCacheEntry cDetails)
		{
			if (!ValConfig.EnableRidableCreatureSizeFixes.Value)
			{
				return;
			}
			Tameable component = creature.GetComponent<Tameable>();
			if ((Object)(object)component != (Object)null && component.IsTamed())
			{
				string prefabName = Utils.GetPrefabName(creature.gameObject);
				if (prefabName == "Lox")
				{
					UpdateLoxCollider(creature.gameObject, cDetails);
				}
				if (prefabName == "Askvin")
				{
					UpdateAskavinCollider(creature.gameObject);
				}
			}
		}

		private static void UpdateLoxCollider(GameObject go, DataObjects.CharacterCacheEntry cDetails)
		{
			CapsuleCollider component = go.GetComponent<CapsuleCollider>();
			if (!((Object)(object)component == (Object)null))
			{
				float num = (DetermineScaleMultiplier(cDetails) - 1f) * 0.1555f;
				component.height = Mathf.Max(0.1f, 3f + num);
				component.radius = 0.5f;
			}
		}

		private static void UpdateAskavinCollider(GameObject go)
		{
			go.GetComponent<CapsuleCollider>().radius = 0.842f;
		}

		internal static void StarLevelScaleChanged(object s, EventArgs e)
		{
			if (ValConfig.EnableCreatureScalingPerLevel.Value)
			{
				Logger.LogInfo($"Updating size scale: {ValConfig.PerLevelScaleBonus.Value} (minimum {ValConfig.MinimumCreatureScale.Value})");
				List<Character> characters = (from chara in Resources.FindObjectsOfTypeAll<Character>()
					where (Object)(object)chara != (Object)null && (Object)(object)chara.m_nview != (Object)null && chara.m_nview.IsValid()
					select chara).ToList();
				ForceUpdateSize = true;
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(ResizeLoadedCreatures(characters));
			}
		}

		private static IEnumerator ResizeLoadedCreatures(List<Character> characters)
		{
			try
			{
				yield return LevelSystemData.UpdateCreatureAttributes(characters);
			}
			finally
			{
				ForceUpdateSize = false;
			}
		}
	}
	internal static class SizePatches
	{
		[HarmonyPatch(typeof(Humanoid), "OnRagdollCreated")]
		public static class ModifyRagdollHumanoid
		{
			public static void Postfix(Character __instance, Ragdoll ragdoll)
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: 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_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || __instance.IsPlayer() || (Object)(object)__instance.m_nview == (Object)null)
				{
					return;
				}
				DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(__instance);
				if (__instance.m_level > 1 && andSetLocalCache != null)
				{
					Vector3 vec = __instance.m_nview.m_zdo.GetVec3(DataObjects.SLS_SIZE, Vector3.zero);
					if (vec != Vector3.zero)
					{
						float x = SizeModifications.GetSizeReferenceForObject(((Object)((Component)__instance).gameObject).name).x;
						float num = (Mathf.Approximately(x, 0f) ? vec.x : (vec.x / x));
						((Component)ragdoll).transform.localScale = SizeModifications.GetSizeReferenceForObject(((Object)((Component)ragdoll).gameObject).name) * num;
					}
					if (andSetLocalCache.Colorization != null)
					{
						Colorization.ApplyColorizationWithoutLevelEffects(((Component)ragdoll).gameObject, andSetLocalCache.Colorization);
					}
				}
				CompositeLazyCache.ClearCachedCreature(__instance);
			}
		}
	}
}
namespace StarLevelSystem.modules.Raids
{
	internal static class RaidControl
	{
		internal static Dictionary<string, DataObjects.PlayerRaidData> ServerPlayerRaidData = new Dictionary<string, DataObjects.PlayerRaidData>();

		internal static RaidManager RaidMan;

		internal static GameObject RaidRunnerGO;

		private static readonly HashSet<RaidRunner> ActiveRaidRunners = new HashSet<RaidRunner>();

		internal static void RegisterActiveRaid(RaidRunner runner)
		{
			if ((Object)(object)runner != (Object)null)
			{
				ActiveRaidRunners.Add(runner);
			}
		}

		internal static void UnregisterActiveRaid(RaidRunner runner)
		{
			if ((Object)(object)runner != (Object)null)
			{
				ActiveRaidRunners.Remove(runner);
			}
		}

		internal static bool AnyActiveRaid()
		{
			ActiveRaidRunners.RemoveWhere((RaidRunner x) => (Object)(object)x == (Object)null);
			return ActiveRaidRunners.Count > 0;
		}

		internal static void LoadAssets()
		{
			RaidRunnerGO = StarLevelSystem.EmbeddedResourceBundle.LoadAsset<GameObject>("RaidRunner.prefab");
		}

		internal static void StartRaidRunner(DataObjects.RaidDefinition targetRaid, Vector3 pos)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Object.Instantiate<GameObject>(RaidRunnerGO, pos, Quaternion.identity).GetComponent<RaidRunner>().StartRaid(targetRaid, Player.m_localPlayer);
		}

		internal static void DispatchForcedRaid(DataObjects.RaidDefinition targetRaid, Vector3 pos)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsDedicated())
			{
				if (!StartNetworkedRaidRunner(targetRaid, pos))
				{
					Logger.LogWarning($"Networked raid dispatch failed for '{targetRaid.Name}' at {pos}; event will be skipped this cycle.");
				}
				return;
			}
			StartRaidRunner(targetRaid, pos);
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Player.m_localPlayer.ShowTutorial("randomevent", false);
			}
		}

		internal static bool StartNetworkedRaidRunner(DataObjects.RaidDefinition targetRaid, Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			ZNetPeer nearestReadyPeer = SLSExtensions.GetNearestReadyPeer(pos);
			if (nearestReadyPeer == null)
			{
				Logger.LogWarning("Unable to start raid " + targetRaid.Name + "; no ready peers were available for the client-side raid runner.");
				return false;
			}
			Vector3 val = pos;
			if (val.y == 0f)
			{
				val.y = nearestReadyPeer.m_refPos.y;
			}
			if (!StartNetworkedRaidForPeer(targetRaid, val, nearestReadyPeer))
			{
				return false;
			}
			ForceMusicForClientsInArea(targetRaid.ForceMusic, val, targetRaid.EventRange * 1.5f);
			return true;
		}

		internal static bool StartNetworkedRaidForPeer(DataObjects.RaidDefinition targetRaid, Vector3 pos, ZNetPeer peer)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (peer == null)
			{
				Logger.LogWarning("Unable to start raid " + targetRaid.Name + "; target peer is null.");
				return false;
			}
			Logger.LogDebug($"Sending networked raid runner for {targetRaid.Name} to {peer.m_playerName} at {pos}");
			ValConfig.ClientStartRaidRPC.SendPackage(peer.m_uid, CreateStartRaidPackage(targetRaid, pos));
			return true;
		}

		internal static ZPackage CreateStartRaidPackage(DataObjects.RaidDefinition targetRaid, Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(DataObjects.yamlSerializer.Serialize((object)new DataObjects.NetworkRaidRequest
			{
				Raid = targetRaid,
				RaidPostion = pos
			}));
			return val;
		}

		public static DataObjects.RaidDefinition RandomSelectValidRaidForPlayer(string playerPlatformID)
		{
			if (RaidsData.SLE_Raid_Settings.Raids.Count == 0)
			{
				Logger.LogWarning("No Raids were defined.");
				return new DataObjects.RaidDefinition();
			}
			Logger.LogDebug("Checking for raids for " + playerPlatformID);
			if (!ServerPlayerRaidData.ContainsKey(playerPlatformID))
			{
				Logger.LogWarning("Player " + playerPlatformID + " was not found and an appropriate raid can't be determined, a random one will be selected. \n  Currently tracked: " + string.Join(",", ServerPlayerRaidData.Keys.ToList()));
				return RaidsData.SLE_Raid_Settings.Raids.ElementAt(Random.Range(0, RaidsData.SLE_Raid_Settings.Raids.Count));
			}
			return ServerPlayerRaidData[playerPlatformID].PlayerAvailableRaids.ElementAt(Random.Range(0, ServerPlayerRaidData[playerPlatformID].PlayerAvailableRaids.Count));
		}

		internal static void UpdateOrAddPlayerPrivateKeys(string playerPlatformID, List<string> privatekeys)
		{
			if (!string.IsNullOrEmpty(playerPlatformID))
			{
				UpdateOrAddPlayerPrivateKeysToRegistry(playerPlatformID, privatekeys);
			}
		}

		internal static void UpdateOrAddPlayerPrivateKeys(long playerID, List<string> privatekeys)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			string text = ((object)SLSExtensions.GetPlatformUserID(playerID)/*cast due to .constrained prefix*/).ToString();
			if (!string.IsNullOrEmpty(text))
			{
				UpdateOrAddPlayerPrivateKeysToRegistry(text, privatekeys);
			}
		}

		private static void UpdateOrAddPlayerPrivateKeysToRegistry(string playerPlatformID, List<string> privatekeys)
		{
			if (ServerPlayerRaidData == null)
			{
				ServerPlayerRaidData = new Dictionary<string, DataObjects.PlayerRaidData>();
			}
			if (ServerPlayerRaidData.ContainsKey(playerPlatformID))
			{
				ServerPlayerRaidData[playerPlatformID].PlayerPrivatekeys = privatekeys;
			}
			else
			{
				ServerPlayerRaidData.Add(playerPlatformID, new DataObjects.PlayerRaidData
				{
					PlayerPrivatekeys = privatekeys
				});
			}
			RaidsData.SaveServerRaidData(DataObjects.yamlSerializer.Serialize((object)ServerPlayerRaidData));
		}

		internal static void UpdatePlayerRaidHistory(DataObjects.PlayerRaidData playerRaidData, DataObjects.RaidDefinition raidDef, string key)
		{
			if (playerRaidData.LastRaidByName.ContainsKey(key))
			{
				playerRaidData.LastRaidByName[key] = ZNet.instance.GetTimeSeconds();
			}
			else
			{
				playerRaidData.LastRaidByName.Add(key, ZNet.instance.GetTimeSeconds());
			}
			playerRaidData.ActiveRaid = raidDef;
			playerRaidData.NextRaidableTime = ZNet.instance.GetTimeSeconds() + (double)(raidDef.RaidCoolDownMinutes * 60f * RaidsData.SLE_Raid_Settings.GlobalSettings.GlobalRaidIntervalScalar);
		}

		internal static void MarkRaidPending(DataObjects.PlayerRaidData playerRaidData, DataObjects.RaidDefinition raidDef, Vector3 pos)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			playerRaidData.ActiveRaid = raidDef;
			playerRaidData.CurrentRaidPosition = pos;
			playerRaidData.NextRaidableTime = ZNet.instance.GetTimeSeconds() + (double)(ValConfig.ServerTimeBetweenRaidStartChecks.Value * 60);
		}

		internal static void FinalizeRaidCommit(string playerPlatformID, string raidName, Vector3 pos)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(playerPlatformID))
			{
				Logger.LogWarning("Raid commit received without a resolvable player; cooldown will not be set.");
				return;
			}
			if (!RaidsData.RaidsByName.TryGetValue(raidName, out var value))
			{
				Logger.LogWarning("Raid commit received for unknown raid '" + raidName + "', ignoring.");
				return;
			}
			if (!ServerPlayerRaidData.TryGetValue(playerPlatformID, out var value2))
			{
				value2 = new DataObjects.PlayerRaidData();
				ServerPlayerRaidData[playerPlatformID] = value2;
			}
			Logger.LogRaid($"Finalizing raid commit '{raidName}' for {playerPlatformID} at {pos}");
			UpdatePlayerRaidHistory(value2, value, value.Name);
			ForceMusicForClientsInArea(value.ForceMusic, pos, value.EventRange * 1.5f);
			RaidsData.SaveServerRaidData(DataObjects.yamlSerializer.Serialize((object)ServerPlayerRaidData));
		}

		internal static void ApplyRaidConfiguration(RandEventSystem res)
		{
			if (!((Object)(object)res == (Object)null) && !ValConfig.UseVanillaRaidConfiguration.Value)
			{
				DataObjects.RaidConfiguration raidConfiguration = RaidsData.SLE_Raid_Settings ?? RaidsData.DefaultConfiguration;
				if (raidConfiguration.GlobalSettings != null && raidConfiguration.GlobalSettings.GlobalRaidIntervalScalar > 0f)
				{
					res.m_eventIntervalMin *= raidConfiguration.GlobalSettings.GlobalRaidIntervalScalar;
				}
				Logger.LogInfo($"SLS raid system: applied {raidConfiguration.Raids.Count} raid definitions.");
			}
		}

		internal static void UpdateAvailableRaidsPerPlayer()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				if (peer.IsReady())
				{
					string text = ((object)SLSExtensions.GetPlatformUserID(peer.m_uid)/*cast due to .constrained prefix*/).ToString();
					List<DataObjects.RaidDefinition> validRaidsForPlayer = GetValidRaidsForPlayer(peer.GetRefPos(), text);
					if (ServerPlayerRaidData.ContainsKey(text))
					{
						ServerPlayerRaidData[text].PlayerAvailableRaids = validRaidsForPlayer;
						continue;
					}
					ServerPlayerRaidData.Add(text, new DataObjects.PlayerRaidData
					{
						PlayerAvailableRaids = validRaidsForPlayer
					});
				}
			}
		}

		internal static List<DataObjects.RaidDefinition> GetValidRaidsForPlayer(Vector3 position, string playerPlatformID)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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)
			List<DataObjects.RaidDefinition> list = new List<DataObjects.RaidDefinition>();
			bool flag = Object.op_Implicit((Object)(object)EffectArea.IsPointInsideArea(position, (Type)4, 30f));
			if (WorldGenerator.instance == null)
			{
				return list;
			}
			Biome biome = WorldGenerator.instance.GetBiome(position);
			foreach (DataObjects.RaidDefinition raid in RaidsData.SLE_Raid_Settings.Raids)
			{
				if (raid.Activation == null || !raid.Enabled)
				{
					continue;
				}
				if (raid.Activation.Biomes != null && !raid.Activation.Biomes.Contains(biome))
				{
					Logger.LogRaid("Player is not in a target biome, skipping selection of Raid: " + raid.Name);
					continue;
				}
				if (raid.Activation.NearBaseOnly && !flag)
				{
					Logger.LogRaid("Player is not in base, skipping selection of Raid: " + raid.Name);
					continue;
				}
				if (raid.Activation.RequiredGlobalKeys != null)
				{
					bool flag2 = true;
					if ((Object)(object)ZoneSystem.instance == (Object)null)
					{
						continue;
					}
					List<string> globalKeys = ZoneSystem.instance.GetGlobalKeys();
					foreach (string requiredGlobalKey in raid.Activation.RequiredGlobalKeys)
					{
						if (!globalKeys.Contains(requiredGlobalKey))
						{
							flag2 = false;
							break;
						}
					}
					if (!flag2)
					{
						Logger.LogRaid("Server does not have a required global key [" + string.Join(",", raid.Activation.RequiredGlobalKeys) + "], skipping Raid: " + raid.Name);
						continue;
					}
				}
				if (raid.Activation.NotRequiredGlobalKeys != null)
				{
					bool flag3 = false;
					if ((Object)(object)ZoneSystem.instance == (Object)null)
					{
						continue;
					}
					List<string> globalKeys2 = ZoneSystem.instance.GetGlobalKeys();
					foreach (string notRequiredGlobalKey in raid.Activation.NotRequiredGlobalKeys)
					{
						if (globalKeys2.Contains(notRequiredGlobalKey))
						{
							flag3 = true;
							break;
						}
					}
					if (flag3)
					{
						Logger.LogRaid("Server has a key that must be missing [" + string.Join(",", raid.Activation.NotRequiredGlobalKeys) + "], skipping Raid: " + raid.Name);
						continue;
					}
				}
				DataObjects.PlayerRaidData playerRaidData = new DataObjects.PlayerRaidData();
				if (ServerPlayerRaidData.ContainsKey(playerPlatformID))
				{
					playerRaidData = ServerPlayerRaidData[playerPlatformID];
				}
				List<string> list2 = playerRaidData.PlayerPrivatekeys ?? new List<string>();
				if (raid.Activation.RequiredPlayerKeys != null)
				{
					bool flag4 = true;
					foreach (string requiredPlayerKey in raid.Activation.RequiredPlayerKeys)
					{
						if (!list2.Contains(requiredPlayerKey))
						{
							flag4 = false;
							break;
						}
					}
					if (!flag4)
					{
						Logger.LogRaid("Player " + playerPlatformID + " does not have a required private key, skipping Raid: " + raid.Name);
						continue;
					}
				}
				if (raid.Activation.AnyRequiredPlayerKeys != null)
				{
					bool flag5 = false;
					foreach (string anyRequiredPlayerKey in raid.Activation.AnyRequiredPlayerKeys)
					{
						if (list2.Contains(anyRequiredPlayerKey))
						{
							flag5 = true;
							break;
						}
					}
					if (!flag5)
					{
						Logger.LogRaid("Player " + playerPlatformID + " does not have any of the required private keys, skipping Raid: " + raid.Name);
						continue;
					}
				}
				if (raid.Activation.NotRequiredPlayerKeys != null)
				{
					bool flag6 = false;
					foreach (string notRequiredPlayerKey in raid.Activation.NotRequiredPlayerKeys)
					{
						if (list2.Contains(notRequiredPlayerKey))
						{
							flag6 = true;
							break;
						}
					}
					if (flag6)
					{
						Logger.LogRaid("Player " + playerPlatformID + " has a private key which must be avoided, skipping Raid: " + raid.Name);
						continue;
					}
				}
				if (playerRaidData.LastRaidByName.Count > 0)
				{
					if (playerRaidData.NextRaidableTime > ZNet.instance.GetTimeSeconds())
					{
						Logger.LogRaid($"Player {playerPlatformID} is next raidable in {ZNet.instance.GetTimeSeconds() - playerRaidData.NextRaidableTime} seconds, skipping Raid: {raid.Name}");
						continue;
					}
					if (playerRaidData.LastRaidByName != null && playerRaidData.LastRaidByName.ContainsKey(raid.Name) && playerRaidData.LastRaidByName[raid.Name] + (double)(raid.RaidCoolDownMinutes * 60f) > ZNet.instance.GetTimeSeconds())
					{
						Logger.LogRaid($"Player {playerPlatformID} has activated Raid {raid.Name} too recently, skipping. Next possible activation time: {ZNet.instance.GetTimeSeconds() - (playerRaidData.LastRaidByName[raid.Name] + (double)(raid.RaidCoolDownMinutes * 60f))}");
						continue;
					}
				}
				Logger.LogRaid("Raid " + raid.Name + " valid for player " + playerPlatformID);
				list.Add(raid);
			}
			return list;
		}

		public static void ForceMusicForClientsInArea(DataObjects.Music music, Vector3 position, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			List<ZNetPeer> list = SLSExtensions.ServerGetPeersInArea(position, range);
			ZPackage val = new ZPackage();
			val.Write(music.ToString());
			foreach (ZNetPeer item in list)
			{
				ValConfig.ClientForcePlayMusicRPC.SendPackage(item.m_uid, val);
			}
		}

		public static void RemoveNearbyRunningEvents()
		{
			Logger.LogRaid("Client recieved remove nearby event command.");
			foreach (RaidRunner item in (IEnumerable<RaidRunner>)Resources.FindObjectsOfTypeAll<RaidRunner>())
			{
				if (!(((Object)item).name == "RaidRunner"))
				{
					Logger.LogRaid("Removing " + ((Object)item).name);
					if ((Object)(object)item.Znet != (Object)null)
					{
						item.Znet.ClaimOwnership();
					}
					ZNetScene.instance.Destroy(((Component)item).gameObject);
				}
			}
		}

		public static IEnumerator DetermineRemoteSpawnLocations(Vector3 origin, DataObjects.ListVectorZNetProperty resultset, int numTargets, DataObjects.BoolZNetProperty pointsReady, float maxDistance = 300f, Biome targetBiome = (Biome)0)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			List<DataObjects.SerializableVector3> spawn_locations = new List<DataObjects.SerializableVector3>();
			int spawn_location_attempts = 0;
			float originalMaxDistance = maxDistance;
			bool allowBaseSpawns = false;
			Vector3 val2 = default(Vector3);
			Biome val3 = default(Biome);
			BiomeArea val4 = default(BiomeArea);
			Heightmap val5 = default(Heightmap);
			while (spawn_locations.Count < numTargets)
			{
				Vector2 val = Random.insideUnitCircle * (maxDistance * 0.8f);
				Vector3 determinedSpawn = origin + new Vector3(val.x, 0f, val.y);
				if (spawn_location_attempts > 100 && spawn_location_attempts % 50 == 0)
				{
					if (spawn_locations.Count > 0)
					{
						break;
					}
					if (maxDistance < originalMaxDistance * 4f)
					{
						maxDistance += 50f;
					}
					else
					{
						if (allowBaseSpawns)
						{
							break;
						}
						Logger.LogRaid("Spawn search exhausted normal range; relaxing the player-base restriction as a last resort.");
						allowBaseSpawns = true;
					}
				}
				if (spawn_location_attempts > 1 && spawn_location_attempts % 10 == 0)
				{
					yield return (object)new WaitForSeconds(0.1f);
				}
				ZoneSystem.instance.GetGroundData(ref determinedSpawn, ref val2, ref val3, ref val4, ref val5);
				if ((int)targetBiome != 0 && ((Object)(object)val5 == (Object)null || val3 != targetBiome))
				{
					spawn_location_attempts++;
					Logger.LogRaid($"Spawn location in the wrong biome, skipping. {val3} | {determinedSpawn}");
					continue;
				}
				float y = determinedSpawn.y;
				float num = 1000f;
				if (ZoneSystem.instance.FindFloor(new Vector3(determinedSpawn.x, determinedSpawn.y + 100f, determinedSpawn.z), ref num))
				{
					float num2 = num - y;
					if (num2 > 1f)
					{
						Logger.LogRaid($"Spawn location blocked by an existing object skipping. {num2} | {determinedSpawn}");
						spawn_location_attempts++;
						continue;
					}
					if (num2 > 0f)
					{
						determinedSpawn.y = num;
					}
					if (!allowBaseSpawns && Object.op_Implicit((Object)(object)EffectArea.IsPointInsideArea(determinedSpawn, (Type)4, 0f)))
					{
						Logger.LogRaid($"Spawn location in a players base zone, skipping. | {determinedSpawn}");
						spawn_location_attempts++;
					}
					else if (determinedSpawn.y < 27f)
					{
						Logger.LogRaid($"Spawn location below water level, skipping. | {determinedSpawn}");
						spawn_location_attempts++;
					}
					else if ((int)val3 == 32 && val5.GetVegetationMask(determinedSpawn) > 0.45f)
					{
						spawn_location_attempts++;
						Logger.LogRaid($"Spawn location is in lava, skipping. | {determinedSpawn}");
					}
					else
					{
						determinedSpawn.y += 1f;
						Logger.LogRaid($"Determined valid spawn target: {determinedSpawn}");
						spawn_locations.Add(determinedSpawn);
					}
				}
				else
				{
					spawn_location_attempts++;
				}
			}
			if (spawn_locations.Count < numTargets)
			{
				Logger.LogWarning($"Unable to find the requested number of spawn points. Found {spawn_locations.Count} spawn locations");
			}
			resultset.ForceSet(spawn_locations);
			pointsReady.ForceSet(value: true);
		}
	}
	public class RaidManager : MonoBehaviour
	{
		private bool setup;

		private double nextCheckForRaidsTime;

		private bool forceRaidStart;

		public void Awake()
		{
			((MonoBehaviour)this).InvokeRepeating("CheckForRaidUpdate", 30f, 30f);
		}

		public void CheckForRaidUpdate()
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0717: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
			if (!setup || ValConfig.UseVanillaRaidConfiguration.Value || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || RaidsData.SLE_Raid_Settings.GlobalSettings.DisableAllRaids || (!forceRaidStart && !(ZNet.instance.GetTimeSeconds() >= nextCheckForRaidsTime)))
			{
				return;
			}
			nextCheckForRaidsTime = ZNet.instance.GetTimeSeconds() + (double)(ValConfig.ServerTimeBetweenRaidStartChecks.Value * 60);
			Logger.LogDebug($"Raid check happening. Next check will be at: {nextCheckForRaidsTime} currentTime: {ZNet.instance.GetTimeSeconds()}");
			int nrOfPlayers = ZNet.instance.GetNrOfPlayers();
			if (nrOfPlayers <= 0)
			{
				Logger.LogDebug("No Players online, skipping raids.");
				return;
			}
			bool flag = false;
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				string value = ((object)SLSExtensions.GetPlatformUserID(peer.m_uid)/*cast due to .constrained prefix*/).ToString();
				if (!Enumerable.Contains(RaidControl.ServerPlayerRaidData.Keys, value))
				{
					ZPackage val = new ZPackage();
					ValConfig.ClientSendPlayerPrivateKeysRPC.SendPackage(peer.m_uid, val);
					flag = true;
				}
			}
			if (flag)
			{
				Logger.LogInfo("Networked players data is needed to ensure accurate raids, delaying raid initilaization and awaiting updated client data.");
				nextCheckForRaidsTime = ZNet.instance.GetTimeSeconds() + 60.0;
				return;
			}
			bool flag2 = false;
			string text = null;
			if (ZNet.instance.IsServer() && !ZNet.instance.IsDedicated() && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				Logger.LogRaid("Integrated server mode enabled, local player will be checked for configuration data. Networked players already validated.");
				text = SLSExtensions.GetLocalUserPlatformAndID();
				RaidControl.UpdateOrAddPlayerPrivateKeys(text, Player.m_localPlayer.GetPrivateKeysSanitize());
				flag2 = true;
			}
			int num = Random.Range(1, Mathf.Min(ValConfig.MaxActiveRaids.Value, nrOfPlayers));
			int num2 = 0;
			int num3 = 0;
			double timeSeconds = ZNet.instance.GetTimeSeconds();
			Logger.LogRaid($"Starting raid init check potential num raids: {num} start-time: {timeSeconds} checking {RaidControl.ServerPlayerRaidData.Count} players for raid availability.");
			List<string> list = new List<string>();
			foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
			{
				list.Add($"{player.m_userInfo.m_id.m_platform}_{player.m_userInfo.m_id.m_userID}");
			}
			Logger.LogRaid("Available players for raids:\n" + string.Join("\n", list) + "\nAvailable Player data:\n" + string.Join("\n", RaidControl.ServerPlayerRaidData.Keys));
			PlayerInfo val2 = default(PlayerInfo);
			foreach (KeyValuePair<string, DataObjects.PlayerRaidData> serverPlayerRaidDatum in RaidControl.ServerPlayerRaidData)
			{
				Logger.LogRaid("Checking raids for " + serverPlayerRaidDatum.Key);
				if (!SLSExtensions.PlatformAndIDIsPlayerOnline(serverPlayerRaidDatum.Key))
				{
					Logger.LogRaid("Client " + serverPlayerRaidDatum.Key + " was not online, skipping raid checks for them.");
					continue;
				}
				if (!forceRaidStart && serverPlayerRaidDatum.Value.NextRaidableTime >= timeSeconds)
				{
					Logger.LogRaid($"{serverPlayerRaidDatum.Key} is not currently raidable, still on cooldown: {serverPlayerRaidDatum.Value.NextRaidableTime} >= {timeSeconds}");
					continue;
				}
				if (num2 >= num)
				{
					Logger.LogRaid($"Number of raids activating now matches: activating {num2} == target {num}");
					break;
				}
				if (!ZNet.TryGetPlayerByPlatformUserID(new PlatformUserID(serverPlayerRaidDatum.Key), ref val2))
				{
					Logger.LogInfo("Could not find player by platform ID " + serverPlayerRaidDatum.Key + ", this player will be skipped.");
					continue;
				}
				Vector3 playerPosition = SLSExtensions.GetPlayerPosition(val2.m_characterID);
				if (playerPosition == Vector3.zero)
				{
					Logger.LogRaid("Player " + serverPlayerRaidDatum.Key + " position was not found, they will not get raided.");
					continue;
				}
				bool flag3 = false;
				foreach (KeyValuePair<string, DataObjects.PlayerRaidData> serverPlayerRaidDatum2 in RaidControl.ServerPlayerRaidData)
				{
					if (!(serverPlayerRaidDatum2.Value.NextRaidableTime < timeSeconds) && serverPlayerRaidDatum2.Value.ActiveRaid != null && serverPlayerRaidDatum2.Value.LastRaidByName.ContainsKey(serverPlayerRaidDatum2.Value.ActiveRaid.Name) && serverPlayerRaidDatum2.Value.LastRaidByName[serverPlayerRaidDatum2.Value.ActiveRaid.Name] + (double)serverPlayerRaidDatum2.Value.ActiveRaid.Duration > timeSeconds && Vector3.Distance((Vector3)serverPlayerRaidDatum2.Value.CurrentRaidPosition, playerPosition) < serverPlayerRaidDatum2.Value.ActiveRaid.EventRange * 3f)
					{
						flag3 = true;
						break;
					}
				}
				if (flag3)
				{
					Logger.LogRaid("Potential raid would be too close to an existing raid, skipping.");
					break;
				}
				Logger.LogRaid("Updating available raids for " + serverPlayerRaidDatum.Key);
				serverPlayerRaidDatum.Value.PlayerAvailableRaids = RaidControl.GetValidRaidsForPlayer(playerPosition, serverPlayerRaidDatum.Key);
				Logger.LogRaid($"Shuffling {serverPlayerRaidDatum.Value.PlayerAvailableRaids.Count} potential raids for player...");
				foreach (DataObjects.RaidDefinition item in serverPlayerRaidDatum.Value.PlayerAvailableRaids.ShuffleList())
				{
					if (num3 >= ValConfig.MaxRaidAttemptsPerPlayer.Value)
					{
						Logger.LogRaid($"Reached max raid attempts per player ({ValConfig.MaxRaidAttemptsPerPlayer.Value}), stopping checks for player {serverPlayerRaidDatum.Key}");
						break;
					}
					num3++;
					float num4 = Random.Range(0f, 100f);
					Logger.LogRaid($"Raid {item} checking activation chance: {num4} <= {item.Activation.Chance * RaidsData.SLE_Raid_Settings.GlobalSettings.GlobalRaidChanceScalar} | Forced? {forceRaidStart}");
					if (!forceRaidStart && !(num4 <= item.Activation.Chance * RaidsData.SLE_Raid_Settings.GlobalSettings.GlobalRaidChanceScalar))
					{
						continue;
					}
					Logger.LogRaid("Activating Raid " + item.Name + " for player " + serverPlayerRaidDatum.Key);
					Logger.LogRaid($"Determining raid init style: integrated? {flag2} && {text} == {serverPlayerRaidDatum.Key}");
					if (flag2 && text == serverPlayerRaidDatum.Key)
					{
						Logger.LogRaid("Starting integrated raid runner.");
						RaidControl.StartRaidRunner(item, playerPosition);
					}
					else
					{
						Logger.LogRaid("Starting networked raid runner.");
						ZNetPeer peerByPlatformID = SLSExtensions.GetPeerByPlatformID(serverPlayerRaidDatum.Key);
						if (!RaidControl.StartNetworkedRaidForPeer(item, playerPosition, peerByPlatformID))
						{
							Logger.LogWarning("Tried to start raid " + item.Name + " for player " + serverPlayerRaidDatum.Key + " but networked dispatch failed (peer null or unavailable).");
							continue;
						}
					}
					RaidControl.MarkRaidPending(serverPlayerRaidDatum.Value, item, playerPosition);
					num2++;
					break;
				}
			}
			forceRaidStart = false;
			RaidsData.SaveServerRaidData(DataObjects.yamlSerializer.Serialize((object)RaidControl.ServerPlayerRaidData));
		}

		public void Setup()
		{
			Logger.LogRaid("Starting setup for RaidManager.");
			try
			{
				RaidControl.ServerPlayerRaidData = DataObjects.yamlDeserializer.Deserialize<Dictionary<string, DataObjects.PlayerRaidData>>(RaidsData.LoadServerRaidData());
			}
			catch (Exception arg)
			{
				Logger.LogWarning($"There was an error loading saved player raid data. New data will be requested from players. Exception: {arg}");
			}
			setup = true;
		}

		public void ForceRaidStart()
		{
			forceRaidStart = true;
		}

		public void OnDestroy()
		{
			RaidsData.SaveServerRaidData(DataObjects.yamlSerializer.Serialize((object)RaidControl.ServerPlayerRaidData));
		}
	}
	internal static class RaidPatches
	{
		[HarmonyPatch(typeof(Player), "AddUniqueKey")]
		internal static class UpdatePlayerPrivateKeys
		{
			public static void Postfix()
			{
				if (ZNet.instance.IsServer() && !((Object)(object)Player.m_localPlayer == (Object)null))
				{
					((MonoBehaviour)TaskRunner.Instance).StartCoroutine(ValConfig.OnClientReceiveRequestForPrivateKeys(1L, null));
				}
			}
		}

		[HarmonyPatch(typeof(Player), "RemoveUniqueKey")]
		internal static class RemovePlayerPrivateKey
		{
			public static void Postfix()
			{
				if (ZNet.instance.IsServer() && !((Object)(object)Player.m_localPlayer == (Object)null))
				{
					((MonoBehaviour)TaskRunner.Instance).StartCoroutine(ValConfig.OnClientReceiveRequestForPrivateKeys(1L, null));
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		internal static class SyncPlayerPrivateKeysOnLoad
		{
			public static void Postfix()
			{
				if (ZNet.instance.IsServer() && !((Object)(object)Player.m_localPlayer == (Object)null))
				{
					((MonoBehaviour)TaskRunner.Instance).StartCoroutine(ValConfig.OnClientReceiveRequestForPrivateKeys(1L, null));
				}
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "Awake")]
		public static class RandEventSystemAwakePatch
		{
			public static void Postfix(RandEventSystem __instance)
			{
				Logger.LogRaid("Adding custom raid manager");
				RaidControl.RaidMan = ((Component)__instance).gameObject.AddComponent<RaidManager>();
				RaidControl.RaidMan.Setup();
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "SetRandomEvent")]
		public static class SetRandomCustomEvent
		{
			public static bool Prefix(RandEventSystem __instance, RandomEvent ev, Vector3 pos)
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				if (ValConfig.UseVanillaRaidConfiguration.Value)
				{
					return true;
				}
				if (ev == null)
				{
					return true;
				}
				Logger.LogRaid("Checking for random Raid " + ev.m_name);
				RaidsData.RaidsByName.TryGetValue(ev.m_name, out var value);
				if (value == null)
				{
					if (Compatibility.CustomRaidsCompatActive)
					{
						Logger.LogRaid("'" + ev.m_name + "' is not an SLS raid; passing through to the vanilla/CustomRaids pipeline.");
						return true;
					}
					Logger.LogWarning("SetRandomEvent called for '" + ev.m_name + "' but no matching SLS raid definition found — event dropped. Add it to RaidSettings.yaml or enable UseVanillaRaidConfiguration.");
					return false;
				}
				RaidControl.DispatchForcedRaid(value, pos);
				return false;
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "StartRandomEvent")]
		public static class RandEventSystemStartEvent
		{
			public static bool Prefix(RandEventSystem __instance)
			{
				if (ValConfig.UseVanillaRaidConfiguration.Value)
				{
					return true;
				}
				if ((Object)(object)RaidControl.RaidMan != (Object)null)
				{
					RaidControl.RaidMan.ForceRaidStart();
				}
				else
				{
					RaidManager component = ((Component)__instance).GetComponent<RaidManager>();
					if ((Object)(object)component != (Object)null)
					{
						RaidControl.RaidMan = component;
						RaidControl.RaidMan.ForceRaidStart();
						return Compatibility.CustomRaidsCompatActive;
					}
					RaidControl.RaidMan = ((Component)__instance).gameObject.AddComponent<RaidManager>();
					RaidControl.RaidMan.Setup();
					RaidControl.RaidMan.ForceRaidStart();
				}
				return Compatibility.CustomRaidsCompatActive;
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "ResetRandomEvent")]
		public static class ResetRandomEvents
		{
			public static bool Prefix()
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				if (ValConfig.UseVanillaRaidConfiguration.Value)
				{
					return true;
				}
				foreach (ZNetPeer peer in ZNet.instance.GetPeers())
				{
					if (peer != null && peer.IsReady())
					{
						ZPackage val = new ZPackage();
						Logger.LogRaid("Sending reset event RPC to " + peer.m_playerName);
						ValConfig.ClientClearNearbyEventsRPC.SendPackage(peer.m_uid, val);
					}
				}
				if (!ZNet.instance.IsDedicated())
				{
					Logger.LogRaid("Running integrated server removal");
					RaidControl.RemoveNearbyRunningEvents();
				}
				return Compatibility.CustomRaidsCompatActive;
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "HaveEvent")]
		public static class AllowSLSRaidEventNames
		{
			public static void Postfix(string name, ref bool __result)
			{
				if (!__result && !ValConfig.UseVanillaRaidConfiguration.Value && RaidsData.RaidsByName.ContainsKey(name))
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "SetRandomEventByName")]
		public static class RouteNamedEventToSLS
		{
			public static bool Prefix(string name, Vector3 pos)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				if (ValConfig.UseVanillaRaidConfiguration.Value)
				{
					return true;
				}
				if (!RaidsData.RaidsByName.TryGetValue(name, out var value))
				{
					return true;
				}
				Logger.LogRaid($"Console force-start routing '{name}' to SLS raid system at {pos}");
				RaidControl.DispatchForcedRaid(value, pos);
				return false;
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "HaveActiveEvent")]
		public static class SlsRaidCountsAsActiveEvent
		{
			public static void Postfix(ref bool __result)
			{
				if (!__result && !ValConfig.UseVanillaRaidConfiguration.Value && RaidControl.AnyActiveRaid())
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "UpdateRandomEvent")]
		public static class OverrideRaidSelectionSystem
		{
			public static bool Prefix()
			{
				if (ValConfig.UseVanillaRaidConfiguration.Value)
				{
					return true;
				}
				if (Compatibility.CustomRaidsCompatActive)
				{
					return true;
				}
				return false;
			}
		}
	}
	public class RaidRunner : MonoBehaviour
	{
		internal ZNetView Znet;

		internal DataObjects.RaidZNetProperty RunningRaid;

		internal DataObjects.DoubleZNetProperty RaitStartTime;

		internal DataObjects.ListVectorZNetProperty RaidSpawnPoints;

		internal DataObjects.BoolZNetProperty RaidSpawnPointsReady;

		internal DataObjects.BoolZNetProperty RaidSpawnPointsGenerating;

		internal DataObjects.RaidMonitorListZNetProperty ActiveRaidSpawns;

		internal DataObjects.BoolZNetProperty RaidStarted;

		internal DataObjects.DoubleZNetProperty RaidWindDownStart;

		private bool networkReady;

		private double Endtime;

		private bool skipCreatureCleanup;

		private List<DataObjects.RaidMonitor> RaidSpawners = new List<DataObjects.RaidMonitor>();

		private PinData AreaPin;

		private PinData IconPin;

		public void Awake()
		{
			Znet = ((Component)this).GetComponent<ZNetView>();
			if (Object.op_Implicit((Object)(object)Znet))
			{
				ConnectZData();
			}
		}

		public void Update()
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Invalid comparison between Unknown and I4
			//IL_0555: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			if (ValConfig.UseVanillaRaidConfiguration.Value || RunningRaid == null || !Znet.IsValid())
			{
				return;
			}
			DataObjects.RaidDefinition raidDefinition = RunningRaid.Get();
			if (RaidStarted.Get())
			{
				EnvMan.instance.m_forceEnv = (IsWindingDown() ? DataObjects.Environment.Clear.ToString() : raidDefinition.ForceEnvironment.ToString());
			}
			if (!Znet.IsOwner())
			{
				return;
			}
			if (!networkReady)
			{
				ConnectZData();
			}
			if (RaidStarted.Get() && !IsWindingDown())
			{
				RaidControl.RegisterActiveRaid(this);
			}
			if (!RaidSpawnPointsReady.Get() && !RaidSpawnPointsGenerating.Get())
			{
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(RaidControl.DetermineRemoteSpawnLocations(((Component)this).transform.position, RaidSpawnPoints, RunningRaid.Get().SpawnPoints, RaidSpawnPointsReady, RunningRaid.Get().EventRange, (Biome)0));
				RaidSpawnPointsGenerating.Set(value: true);
			}
			else
			{
				if (!RaidSpawnPointsReady.Get() && RaidSpawnPointsGenerating.Get())
				{
					return;
				}
				if (RaidSpawnPointsReady.Get())
				{
					List<DataObjects.SerializableVector3> list = RaidSpawnPoints.Get();
					if (list == null || list.Count == 0)
					{
						Logger.LogRaid("Raid failed to find any valid spawn points, stopping raid.");
						RemoveExistingMapPins();
						Object.Destroy((Object)(object)this);
						return;
					}
				}
				if (ActiveRaidSpawns.Get().Count <= 0)
				{
					RaitStartTime.Set(ZNet.instance.GetTimeSeconds());
					Endtime = RaitStartTime.Get() + (double)raidDefinition.Duration;
					AddMapPins(((Component)this).transform.position, raidDefinition);
					Player.MessageAllInRange(((Component)this).transform.position, raidDefinition.EventRange * 1.5f, (MessageType)2, raidDefinition.StartMessage, (Sprite)null);
					RaidStarted.Set(value: true);
					RaidControl.RegisterActiveRaid(this);
					if ((Object)(object)MusicMan.instance != (Object)null)
					{
						MusicMan.instance.TriggerMusic(raidDefinition.ForceMusic.ToString());
					}
					SendRaidCommitConfirmation(raidDefinition, ((Component)this).transform.position);
					RaidSpawners.Clear();
					foreach (DataObjects.RaidSpawnEntry spawn in raidDefinition.Spawns)
					{
						RaidSpawners.Add(new DataObjects.RaidMonitor
						{
							RaidSpawnDef = spawn,
							NextSpawn = ZNet.instance.GetTimeSeconds() + (double)spawn.InitalSpawnDelay
						});
					}
					ActiveRaidSpawns.Set(RaidSpawners);
					{
						foreach (Player item in SLSExtensions.GetPlayersInRange(((Component)this).transform.position, raidDefinition.EventRange * 1.5f))
						{
							item.ShowTutorial("randomevent", false);
						}
						return;
					}
				}
				if (Endtime == 0.0)
				{
					Endtime = RaitStartTime.Get() + (double)RunningRaid.Get().Duration;
				}
				if (RaidSpawners.Count != ActiveRaidSpawns.Get().Count)
				{
					RaidSpawners = ActiveRaidSpawns.Get();
				}
				bool flag = Endtime < ZNet.instance.GetTimeSeconds();
				foreach (DataObjects.RaidMonitor raidSpawner in RaidSpawners)
				{
					if (flag || (raidSpawner.RaidSpawnDef.MaxSpawnTriggers > 0 && raidSpawner.TriggerCount >= raidSpawner.RaidSpawnDef.MaxSpawnTriggers) || raidSpawner.NextSpawn > ZNet.instance.GetTimeSeconds())
					{
						continue;
					}
					Logger.LogRaid($"Checking {raidSpawner.RaidSpawnDef.PrefabName} spawn timer: {raidSpawner.NextSpawn} < {ZNet.instance.GetTimeSeconds()}");
					raidSpawner.NextSpawn = ZNet.instance.GetTimeSeconds() + (double)raidSpawner.RaidSpawnDef.SpawnInterval;
					List<ZDOID> list2 = (from x in raidSpawner.GetSpawnedZDOIDs()
						where ZDOMan.instance.GetZDO(x) != null
						select x).ToList();
					Logger.LogRaid($"Found {list2.Count} alive creatures");
					if (list2.Count > raidSpawner.RaidSpawnDef.MaxSpawned)
					{
						continue;
					}
					List<DataObjects.SerializableVector3> list3 = RaidSpawnPoints.Get();
					GameObject prefab = PrefabManager.Instance.GetPrefab(raidSpawner.RaidSpawnDef.PrefabName);
					if ((Object)(object)prefab == (Object)null)
					{
						Logger.LogWarning("The creature defined for this wave is invalid and will be skipped. |" + raidSpawner.RaidSpawnDef.PrefabName + "|");
					}
					float num = Random.Range(0f, 100f);
					if (raidSpawner.RaidSpawnDef.SpawnChance < num)
					{
						Logger.LogRaid($"{raidSpawner.RaidSpawnDef.PrefabName} Failed spawn chance roll {raidSpawner.RaidSpawnDef.SpawnChance} < {num}");
						continue;
					}
					raidSpawner.TriggerCount++;
					Vector3 val = list3[Random.Range(0, list3.Count - 1)];
					SortedDictionary<int, float> creature_levelup_chance = LevelGeneratorResolver.BuildLevelupChance(raidSpawner.RaidSpawnDef.LevelupGenerators, raidSpawner.RaidSpawnDef.LevelupGeneratorRefs) ?? LevelSelection.DetermineLevelupChance(null, null, raidSpawner.RaidSpawnDef.CustomCreatureLevelUpChance);
					SortedDictionary<int, float> levelup_bonus = LevelSelection.DetermineDistanceBonus(val);
					int num2 = 0;
					while (num2 < raidSpawner.RaidSpawnDef.SpawnGroupSize)
					{
						int num3 = 0;
						if (raidSpawner.RaidSpawnDef.UseRaidLevelSystem)
						{
							num3 = LevelSelection.DetermineLevelRollResult(Random.Range(0f, 100f), raidSpawner.RaidSpawnDef.LevelMax, creature_levelup_chance, levelup_bonus, 1f);
							Logger.LogRaid($"Spawning {raidSpawner.RaidSpawnDef.PrefabName} at {val} level {num3}");
						}
						else
						{
							Logger.LogRaid($"Spawning {raidSpawner.RaidSpawnDef.PrefabName} at {val}");
						}
						GameObject val2 = Object.Instantiate<GameObject>(prefab, val, Random.rotation);
						num2++;
						MonsterAI component = val2.GetComponent<MonsterAI>();
						component.SetEventCreature(true);
						CreatureSetupControl.ApplySpawnAI(component, raidSpawner.RaidSpawnDef.CreatureAI);
						Character component2 = val2.GetComponent<Character>();
						if ((int)raidSpawner.RaidSpawnDef.Faction != 12)
						{
							component2.m_faction = raidSpawner.RaidSpawnDef.Faction;
						}
						CreatureSetupControl.CreatureSpawnerSetup(component2, num3, multiply: false, 0.1f, raidSpawner.RaidSpawnDef.RequiredModifiers, raidSpawner.RaidSpawnDef.ModifiersNotAllowed);
						list2.Add(val2.GetComponent<ZNetView>().GetZDO().m_uid);
						raidSpawner.StoreZDOIDS(list2);
					}
				}
				ActiveRaidSpawns.Set(RaidSpawners);
				if (!flag)
				{
					return;
				}
				bool flag2 = !RunningRaid.Get().RaidActiveTillDefeated;
				bool flag3 = false;
				foreach (DataObjects.RaidMonitor raidSpawner2 in RaidSpawners)
				{
					if (raidSpawner2.RaidSpawnDef.MaxSpawnTriggers > 0 && raidSpawner2.TriggerCount >= raidSpawner2.RaidSpawnDef.MaxSpawnTriggers)
					{
						flag2 = true;
					}
					if (raidSpawner2.RaidSpawnDef.MaxSpawnTriggers == 0)
					{
						flag2 = true;
					}
					if (raidSpawner2.RaidSpawnDef.MaxSpawned > 0 && raidSpawner2.TriggerCount >= raidSpawner2.RaidSpawnDef.MaxSpawned)
					{
						flag3 = true;
					}
					if (raidSpawner2.RaidSpawnDef.MaxSpawned == 0)
					{
						flag3 = true;
					}
				}
				if (flag2 && flag3)
				{
					if (!IsWindingDown())
					{
						BeginWindDown(raidDefinition);
					}
					else
					{
						UpdateWindDown();
					}
				}
			}
		}

		public void OnDestroy()
		{
			RaidControl.UnregisterActiveRaid(this);
			RemoveExistingMapPins();
			if ((Object)(object)MusicMan.instance != (Object)null)
			{
				MusicMan.instance.StopMusic();
			}
			if ((Object)(object)EnvMan.instance != (Object)null)
			{
				EnvMan.instance.m_forceEnv = DataObjects.Environment.Clear.ToString();
			}
			if (!skipCreatureCleanup)
			{
				ForceDestroyTrackedCreatures();
			}
		}

		private bool IsWindingDown()
		{
			if (RaidWindDownStart != null)
			{
				return RaidWindDownStart.Get() > 0.0;
			}
			return false;
		}

		private void BeginWindDown(DataObjects.RaidDefinition raid)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogRaid(raid.Name + " ending — creatures dispersing.");
			RaidWindDownStart.Set(ZNet.instance.GetTimeSeconds());
			RaidControl.UnregisterActiveRaid(this);
			RemoveExistingMapPins();
			Player.MessageAllInRange(((Component)this).transform.position, raid.EventRange * 1.5f, (MessageType)2, raid.EndMessage, (Sprite)null);
			if ((Object)(object)MusicMan.instance != (Object)null)
			{
				MusicMan.instance.StopMusic();
			}
			if ((Object)(object)EnvMan.instance != (Object)null)
			{
				EnvMan.instance.m_forceEnv = DataObjects.Environment.Clear.ToString();
			}
		}

		private void UpdateWindDown()
		{
			int num = 0;
			foreach (DataObjects.RaidMonitor raidSpawner in RaidSpawners)
			{
				List<ZDOID> list = (from x in raidSpawner.GetSpawnedZDOIDs()
					where ZDOMan.instance.GetZDO(x) != null
					select x).ToList();
				raidSpawner.StoreZDOIDS(list);
				num += list.Count;
			}
			ActiveRaidSpawns.Set(RaidSpawners);
			if (num == 0)
			{
				Logger.LogRaid("Raid wind-down complete, all creatures dispersed.");
				skipCreatureCleanup = true;
				Object.Destroy((Object)(object)this);
				return;
			}
			double num2 = RaidWindDownStart.Get() + (double)ValConfig.RaidWindDownSeconds.Value;
			if (!(ZNet.instance.GetTimeSeconds() <= num2))
			{
				if (ValConfig.RaidForceDeleteStragglers.Value)
				{
					Logger.LogRaid($"Raid wind-down window elapsed; force-deleting {num} remaining creature(s).");
					ForceDestroyTrackedCreatures();
				}
				else
				{
					Logger.LogRaid($"Raid wind-down window elapsed; leaving {num} remaining creature(s) to despawn on their own.");
					skipCreatureCleanup = true;
				}
				Object.Destroy((Object)(object)this);
			}
		}

		private void ForceDestroyTrackedCreatures()
		{
			//IL_0078: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			List<DataObjects.RaidMonitor> list = ((RaidSpawners != null && RaidSpawners.Count > 0) ? RaidSpawners : ((networkReady && ActiveRaidSpawns != null) ? ActiveRaidSpawns.Get() : null));
			if (list == null)
			{
				return;
			}
			foreach (DataObjects.RaidMonitor item in list)
			{
				foreach (ZDOID spawnedZDOID in item.GetSpawnedZDOIDs())
				{
					ZDO zDO = ZDOMan.instance.GetZDO(spawnedZDOID);
					if (zDO != null)
					{
						ZNetView val = ZNetScene.instance.FindInstance(zDO);
						if (!((Object)(object)val == (Object)null) && (Object)(object)val != (Object)null)
						{
							val.ClaimOwnership();
							ZNetScene.instance.Destroy(((Component)val).gameObject);
						}
					}
				}
			}
		}

		private void ConnectZData()
		{
			RunningRaid = new DataObjects.RaidZNetProperty("SLS_RAID", Znet, null);
			RaitStartTime = new DataObjects.DoubleZNetProperty("SLS_RAID_START", Znet, 0.0);
			RaidSpawnPoints = new DataObjects.ListVectorZNetProperty("SLS_RAID_SPAWN_POINTS", Znet, null);
			RaidSpawnPointsReady = new DataObjects.BoolZNetProperty("SLS_RAID_SPAWN_READY", Znet, defaultValue: false);
			RaidSpawnPointsGenerating = new DataObjects.BoolZNetProperty("SLS_RAID_SPAWN_GEN", Znet, defaultValue: false);
			ActiveRaidSpawns = new DataObjects.RaidMonitorListZNetProperty("SLS_RAID_SPAWNS_ACTIVE", Znet, new List<DataObjects.RaidMonitor>());
			RaidStarted = new DataObjects.BoolZNetProperty("SLS_RAID_STARTED", Znet, defaultValue: false);
			RaidWindDownStart = new DataObjects.DoubleZNetProperty("SLS_RAID_WINDDOWN", Znet, 0.0);
			networkReady = true;
		}

		private void SendRaidCommitConfirmation(DataObjects.RaidDefinition raid, Vector3 pos)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			if (ZNet.instance.IsServer())
			{
				RaidControl.FinalizeRaidCommit(SLSExtensions.GetLocalUserPlatformAndID(), raid.Name, pos);
				return;
			}
			ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
			if (serverPeer == null)
			{
				Logger.LogWarning("Raid '" + raid.Name + "' committed but no server peer was available to confirm it; cooldown/music may not be applied.");
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(raid.Name);
			val.Write(pos.x);
			val.Write(pos.y);
			val.Write(pos.z);
			ValConfig.RaidCommittedRPC.SendPackage(serverPeer.m_uid, val);
		}

		public void StartRaid(DataObjects.RaidDefinition raid, Player player)
		{
			Znet.ClaimOwnership();
			RunningRaid.ForceSet(raid);
			RaitStartTime.ForceSet(ZNet.instance.GetTimeSeconds());
			Logger.LogRaid("Starting Raid " + raid.Name);
		}

		public void AddMapPins(Vector3 pos, DataObjects.RaidDefinition raid)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			RemoveExistingMapPins();
			AreaPin = Minimap.instance.AddPin(pos, (PinType)13, "", false, false, 0L, default(PlatformUserID));
			AreaPin.m_worldSize = raid.EventRange * 2f;
			IconPin = Minimap.instance.AddPin(pos, (PinType)11, "", false, false, 0L, default(PlatformUserID));
			IconPin.m_animate = true;
			IconPin.m_doubleSize = true;
		}

		public void RemoveExistingMapPins()
		{
			if (AreaPin != null)
			{
				Minimap.instance.RemovePin(AreaPin);
				AreaPin = null;
			}
			if (IconPin != null)
			{
				Minimap.instance.RemovePin(IconPin);
				IconPin = null;
			}
		}
	}
}
namespace StarLevelSystem.modules.NemesisSystem
{
	internal static class NemesisActions
	{
		private static readonly List<DataObjects.NemesisAction> SpawnActions = new List<DataObjects.NemesisAction>
		{
			DataObjects.NemesisAction.Spawn,
			DataObjects.NemesisAction.SpawnMiniboss
		};

		public static int LevelSystemDetermineNemesisInfluence(Character character, int min_level, int max_level, int current_level)
		{
			int num = current_level;
			if ((Object)(object)NemesisSystem.NemesisManager == (Object)null || !NemesisSystem.NemesisManager.IsSetup || NemesisSystem.PlayerScore == null)
			{
				return num;
			}
			bool num2 = character.IsBoss();
			string key = ((Object)((Component)character).gameObject).name.Replace("(Clone)", "");
			if (num2)
			{
				if (!NemesisSystem.PlayerScore.BossKillsHistory.ContainsKey(key) && NemesisSystemData.SLE_Nemesis_Settings.GaurenteedChanges.FirstBossSetLevel)
				{
					return NemesisSystemData.SLE_Nemesis_Settings.GaurenteedChanges.FirstBossLevel;
				}
			}
			else if ((Object)(object)NemesisSystem.NemesisManager != (Object)null && NemesisSystem.NemesisManager.ReadyForNextNemesisAction() && NemesisSystemData.SLE_Nemesis_Settings.ChanceChanges != null && NemesisSystemData.SLE_Nemesis_Settings.ChanceChanges != null)
			{
				foreach (KeyValuePair<string, DataObjects.NemesisChanceEntry> creatureOp in NemesisSystemData.SLE_Nemesis_Settings.ChanceChanges.CreatureOps)
				{
					if (!creatureOp.Value.Enabled || creatureOp.Value.Action != DataObjects.NemesisAction.ChangeLevel)
					{
						continue;
					}
					if (!MeetsScoreThreshold(creatureOp.Value.ScoreThreshold))
					{
						Logger.LogNemesis($"{creatureOp.Key} skipped due to player score {NemesisSystem.CachedPlayerScore:0.0} not meeting threshold {creatureOp.Value.ScoreThreshold:0.0}.");
						continue;
					}
					if (Random.Range(0f, 1f) > creatureOp.Value.Chance)
					{
						Logger.LogNemesis(creatureOp.Key + " failed chance roll.");
						continue;
					}
					num = Mathf.Clamp(creatureOp.Value.LevelBonus + num, min_level, max_level);
					NemesisSystem.NemesisManager.RecordNemesisAction($"Changed {character.m_name} level by {creatureOp.Value.LevelBonus}({num}) due to {creatureOp.Key} spawn with score {NemesisSystem.CachedPlayerScore}");
					if (creatureOp.Value.ScoreChange != 0f)
					{
						NemesisScoreSystem.UpdateScore(Player.m_localPlayer, creatureOp.Value.ScoreChange);
					}
					break;
				}
			}
			return num;
		}

		public static void NemesisRandomSpawner(Character chara)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0619: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0700: Unknown result type (might be due to invalid IL or missing references)
			//IL_0686: Unknown result type (might be due to invalid IL or missing references)
			//IL_053f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0769: Unknown result type (might be due to invalid IL or missing references)
			//IL_0773: Expected O, but got Unknown
			//IL_0836: Unknown result type (might be due to invalid IL or missing references)
			//IL_0841: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NemesisSystem.NemesisManager == (Object)null || !NemesisSystem.NemesisManager.IsSetup || !NemesisSystem.NemesisManager.ReadyForNextNemesisAction())
			{
				return;
			}
			float num = Vector3.Distance(((Component)chara).transform.position, ((Component)Player.m_localPlayer).transform.position);
			if (num > NemesisSystemData.SLE_Nemesis_Settings.NemesisInfluenceRadius || num < NemesisSystemData.SLE_Nemesis_Settings.NemesisMinSpawnDistance)
			{
				return;
			}
			List<string> playerPrivateKeys = Player.m_localPlayer.GetPrivateKeysSanitize();
			Biome val = Heightmap.FindBiome(((Component)chara).transform.position);
			Biome val2 = Heightmap.FindBiome(((Component)Player.m_localPlayer).transform.position);
			foreach (KeyValuePair<string, DataObjects.NemesisChanceEntry> creatureOp in NemesisSystemData.SLE_Nemesis_Settings.ChanceChanges.CreatureOps)
			{
				if (!creatureOp.Value.Enabled || !SpawnActions.Contains(creatureOp.Value.Action))
				{
					continue;
				}
				if (creatureOp.Value.RequiredGlobalKeys != null && creatureOp.Value.RequiredGlobalKeys.Count > 0 && creatureOp.Value.RequiredGlobalKeys.Any((string key) => !ZoneSystem.instance.GetGlobalKey(key)))
				{
					bool flag = true;
					foreach (string requiredGlobalKey in creatureOp.Value.RequiredGlobalKeys)
					{
						if (!ZoneSystem.instance.GetGlobalKey(requiredGlobalKey))
						{
							flag = false;
							Logger.LogNemesis(creatureOp.Key + " skipped due to server missing a required global key (" + requiredGlobalKey + ") in " + string.Join(", ", creatureOp.Value.RequiredGlobalKeys));
							break;
						}
					}
					if (!flag)
					{
						continue;
					}
				}
				if (creatureOp.Value.NotRequiredGlobalKeys != null && creatureOp.Value.NotRequiredGlobalKeys.Count > 0 && creatureOp.Value.NotRequiredGlobalKeys.Any((string key) => ZoneSystem.instance.GetGlobalKey(key)))
				{
					bool flag2 = true;
					foreach (string notRequiredGlobalKey in creatureOp.Value.NotRequiredGlobalKeys)
					{
						if (ZoneSystem.instance.GetGlobalKey(notRequiredGlobalKey))
						{
							flag2 = false;
							Logger.LogNemesis(creatureOp.Key + " skipped due to server having an unwanted global key (" + notRequiredGlobalKey + ") in " + string.Join(", ", creatureOp.Value.NotRequiredGlobalKeys));
							break;
						}
					}
					if (!flag2)
					{
						continue;
					}
				}
				if (creatureOp.Value.RequiredPrivateKeys != null && creatureOp.Value.RequiredPrivateKeys.Count > 0 && creatureOp.Value.RequiredPrivateKeys.Any((string key) => !playerPrivateKeys.Contains(key)))
				{
					bool flag3 = true;
					foreach (string requiredPrivateKey in creatureOp.Value.RequiredPrivateKeys)
					{
						if (!playerPrivateKeys.Contains(requiredPrivateKey))
						{
							flag3 = false;
							Logger.LogNemesis(creatureOp.Key + " skipped due to server missing a required private key (" + requiredPrivateKey + ") in " + string.Join(", ", creatureOp.Value.RequiredPrivateKeys));
							break;
						}
					}
					if (!flag3)
					{
						continue;
					}
				}
				if (creatureOp.Value.PlayerReqs != null)
				{
					if ((int)creatureOp.Value.PlayerReqs.PlayerCurrentBiome != 0 && creatureOp.Value.PlayerReqs.PlayerCurrentBiome != val2)
					{
						Logger.LogNemesis(creatureOp.Key + " skipped due to player not being in the current required biome.");
						continue;
					}
					float healthPercentage = ((Character)Player.m_localPlayer).GetHealthPercentage();
					if (creatureOp.Value.PlayerReqs.PlayerHealthPercentAbove != 0f && healthPercentage <= creatureOp.Value.PlayerReqs.PlayerHealthPercentAbove)
					{
						Logger.LogNemesis($"{creatureOp.Key} skipped due to player health percentage not above the requirement ({healthPercentage}) req: {creatureOp.Value.PlayerReqs.PlayerHealthPercentAbove}.");
						continue;
					}
					if (creatureOp.Value.PlayerReqs.PlayerHealthPercentBelow != 0f && healthPercentage >= creatureOp.Value.PlayerReqs.PlayerHealthPercentBelow)
					{
						Logger.LogNemesis($"{creatureOp.Key} skipped due to player health percentage not below the requirement ({healthPercentage}) req: {creatureOp.Value.PlayerReqs.PlayerHealthPercentBelow}.");
						continue;
					}
					if (creatureOp.Value.PlayerReqs.MinBiomeHistory > 0 && NemesisScoreSystem.PlayerRecentBiomeCount(val) < creatureOp.Value.PlayerReqs.MinBiomeHistory)
					{
						Logger.LogNemesis($"{creatureOp.Key} skipped due to not meeting the minimum biome history requirement ({NemesisScoreSystem.PlayerRecentBiomeCount(val)} < {creatureOp.Value.PlayerReqs.MinBiomeHistory}).");
						continue;
					}
				}
				if (creatureOp.Value.ScoreThreshold != 0f && !MeetsScoreThreshold(creatureOp.Value.ScoreThreshold))
				{
					Logger.LogNemesis($"{creatureOp.Key} skipped due to player score {NemesisSystem.CachedPlayerScore:0.0} not meeting threshold {creatureOp.Value.ScoreThreshold:0.0}.");
					continue;
				}
				if (creatureOp.Value.AllowedBiomes != null && creatureOp.Value.AllowedBiomes.Count > 0 && !creatureOp.Value.AllowedBiomes.Contains(val))
				{
					Logger.LogNemesis($"{creatureOp.Key} skipped due to not being an allowed biome Allowed: {creatureOp.Value.AllowedBiomes} Current: {val}.");
					continue;
				}
				if (creatureOp.Value.DeniedBiomes != null && creatureOp.Value.DeniedBiomes.Count > 0 && creatureOp.Value.DeniedBiomes.Contains(val))
				{
					Logger.LogNemesis(string.Format("{0} skipped due to being in a denied biome: {1} Current: {2}.", creatureOp.Key, string.Join(", ", creatureOp.Value.DeniedBiomes), val));
					continue;
				}
				if (Random.Range(0f, 1f) > creatureOp.Value.Chance)
				{
					Logger.LogNemesis(creatureOp.Key + " failed chance roll.");
					continue;
				}
				string text = "";
				List<DataObjects.NemesisSpawn> list = creatureOp.Value.SpawnConfig;
				if (creatureOp.Value.Action == DataObjects.NemesisAction.SpawnMiniboss)
				{
					DataObjects.NemesisMiniboss nemesisMiniboss = NemesisMiniBossManager.RandomlySelectAppropriateMiniboss(((Component)chara).transform.position);
					if (nemesisMiniboss == null)
					{
						continue;
					}
					text = text + "Selected NemesisBoss: " + nemesisMiniboss.BossSpawn.CustomName + " to spawn. ";
					IEnumerable<DataObjects.NemesisSpawn> enumerable = new List<DataObjects.NemesisSpawn>(nemesisMiniboss.Minions);
					list = (List<DataObjects.NemesisSpawn>)(enumerable ?? Enumerable.Empty<DataObjects.NemesisSpawn>());
					list.Add(nemesisMiniboss.BossSpawn);
					ZPackage removeBossPack = new ZPackage();
					removeBossPack.Write(DataObjects.yamlSerializer.Serialize((object)nemesisMiniboss));
					if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
					{
						ZNet.instance.GetPeers().ForEach(delegate(ZNetPeer peer)
						{
							ValConfig.RemoveNemesisBossRPC.SendPackage(peer.m_uid, removeBossPack);
						});
					}
					else
					{
						ZNet instance = ZNet.instance;
						ZNetPeer val3 = ((instance != null) ? instance.GetServerPeer() : null);
						if (val3 != null)
						{
							ValConfig.RemoveNemesisBossRPC.SendPackage(val3.m_uid, removeBossPack);
						}
					}
					NemesisSystemData.SLE_Nemesis_Settings.AvailableMiniBosses.Remove(nemesisMiniboss);
				}
				foreach (DataObjects.NemesisSpawn item in list)
				{
					if (item.IsBoss)
					{
						text += "Miniboss Spawn ";
					}
					NemesisRemoteSpawnControl.SpawnNemesisSpawn(item, ((Component)chara).transform.position, ((Component)chara).transform.rotation, creatureOp.Value.LevelBonus, null, null);
					text += $" {item.Prefab}x{item.SpawnGroupSize}";
				}
				NemesisSystem.NemesisManager.RecordNemesisAction($"Spawn event {creatureOp.Key}, {text} | score {NemesisSystem.CachedPlayerScore:0.0}");
				if (creatureOp.Value.ExtraCooldownSeconds > 0f)
				{
					NemesisSystem.NemesisManager.AddCooldownForNextNemesisAction(creatureOp.Value.ExtraCooldownSeconds);
				}
				if (creatureOp.Value.ScoreChange != 0f)
				{
					NemesisScoreSystem.UpdateScore(Player.m_localPlayer, creatureOp.Value.ScoreChange);
				}
				break;
			}
		}

		internal static bool MeetsScoreThreshold(float scoreThreshold)
		{
			if (scoreThreshold > NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.NeutralScore && NemesisSystem.CachedPlayerScore < scoreThreshold)
			{
				return false;
			}
			if (scoreThreshold < NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.NeutralScore && NemesisSystem.CachedPlayerScore > scoreThreshold)
			{
				return false;
			}
			return true;
		}
	}
	internal static class NemesisSystem
	{
		internal static DataObjects.ScoreData PlayerScore = null;

		internal static NemesisManager NemesisManager = null;

		internal static float CachedPlayerScore = 0f;

		internal static List<Biome> PlayerRecentBiomes = new List<Biome>();

		internal static void Initialize()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)NemesisManager != (Object)null))
			{
				GameObject val = new GameObject("SLS_NemesisManager");
				Object.DontDestroyOnLoad((Object)val);
				((Object)val).hideFlags = (HideFlags)61;
				NemesisManager = val.AddComponent<NemesisManager>();
				Logger.LogInfo("Nemesis System initialized.");
			}
		}
	}
	internal class NemesisManager : MonoBehaviour
	{
		private Player player;

		private bool setup;

		private List<string> NemesisActionLog = new List<string>();

		public double nextRecalcTime;

		public double nextNemeisActionTime;

		public bool IsSetup => setup;

		public void Awake()
		{
			((MonoBehaviour)this).InvokeRepeating("CheckAndUpdateNemesis", 5f, 5f);
		}

		public void CheckAndUpdateNemesis()
		{
			if (!ValConfig.EnableNemesisSystem.Value || !setup || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			if ((Object)(object)player == (Object)null)
			{
				setup = false;
			}
			else
			{
				if (!(ZNet.instance.GetTimeSeconds() >= nextRecalcTime))
				{
					return;
				}
				NemesisScoreSystem.UpdateScore(player);
				nextRecalcTime = ZNet.instance.GetTimeSeconds() + (double)NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.ScoreIntervalSeconds;
				NemesisScoreSystem.SaveScoreData(player);
				NemesisScoreSystem.UpdatePlayerRecentBiomes();
				if (NemesisActionLog.Count <= 0)
				{
					return;
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine($"{ZNet.instance.GetTimeSeconds()} | Score: {NemesisScoreSystem.GetScore(player)} | Actions: {NemesisActionLog.Count}");
				foreach (string item in NemesisActionLog)
				{
					stringBuilder.AppendLine(item);
				}
				NemesisSystemData.UpdateNemesisLog(stringBuilder.ToString());
				NemesisActionLog.Clear();
			}
		}

		public void RecordNemesisAction(string nemSummary)
		{
			nextNemeisActionTime = ZNet.instance.GetTimeSeconds() + (double)NemesisSystemData.SLE_Nemesis_Settings.NemesisActionCooldownSeconds;
			NemesisActionLog.Add("  " + nemSummary);
		}

		public bool ReadyForNextNemesisAction()
		{
			return ZNet.instance.GetTimeSeconds() >= nextNemeisActionTime;
		}

		public void AddCooldownForNextNemesisAction(float seconds)
		{
			nextNemeisActionTime += seconds;
		}

		internal void Setup(Player p)
		{
			player = p;
			if (!((Object)(object)player == (Object)null))
			{
				NemesisScoreSystem.LoadScoreData(player);
				NemesisSystem.CachedPlayerScore = NemesisScoreSystem.GetScore(player);
				double num = (((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetTimeSeconds() : 0.0);
				nextRecalcTime = num + (double)NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.ScoreIntervalSeconds;
				NemesisSystem.NemesisManager = this;
				setup = true;
			}
		}
	}
	internal static class NemesisMiniBossManager
	{
		internal static int NumNemesisNames = 9;

		internal static int NumNemesisPrefixes = 6;

		internal static int NumNemesisPostfixes = 4;

		public static string RandomlySelectBossName(string playername, bool include_postfix = true, bool include_prefix = true)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (include_prefix && Random.Range(0f, 1f) < 0.1f)
			{
				stringBuilder.Append("$SLS_Miniboss_Prefix" + Random.Range(1, NumNemesisPrefixes) + " ");
			}
			stringBuilder.Append("$SLS_Miniboss_Name" + Random.Range(1, NumNemesisNames));
			if (include_postfix && Random.Range(0f, 1f) < 0.25f)
			{
				stringBuilder.Append(" $SLS_Miniboss_postfix" + Random.Range(1, NumNemesisPostfixes) + " " + playername);
			}
			return stringBuilder.ToString();
		}

		public static DataObjects.NemesisMiniboss RandomlySelectAppropriateMiniboss(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return RandomlySelectAppropriateMiniboss(Heightmap.FindBiome(pos));
		}

		public static DataObjects.NemesisMiniboss RandomlySelectAppropriateMiniboss(Biome targetBiome)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			foreach (DataObjects.NemesisMiniboss item in NemesisSystemData.SLE_Nemesis_Settings.AvailableMiniBosses.ShuffleList())
			{
				if (item.Biome == targetBiome)
				{
					return item;
				}
			}
			return null;
		}

		public static List<DataObjects.NemesisSpawn> GenerateMinionsForBiome(Biome biome, int minGroups = 1, int maxGroups = 4)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			List<DataObjects.NemesisSpawn> list = new List<DataObjects.NemesisSpawn>();
			if (NemesisSystemData.SLE_Nemesis_Settings.NemesisMinionTemplatesByBiome != null && NemesisSystemData.SLE_Nemesis_Settings.NemesisMinionTemplatesByBiome.TryGetValue(biome, out var value) && value.Count > 0)
			{
				int num = Random.Range(minGroups, maxGroups);
				while (num > 0)
				{
					num--;
					DataObjects.NemesisMinion nemesisMinion = value[Random.Range(0, value.Count)];
					GameObject prefab = PrefabManager.Instance.GetPrefab(nemesisMinion.PrefabName);
					if (!((Object)(object)prefab == (Object)null))
					{
						Character component = prefab.GetComponent<Character>();
						if ((Object)(object)component != (Object)null)
						{
							list.Add(new DataObjects.NemesisSpawn
							{
								Faction = (Faction)8,
								CustomName = "$SLS_minion " + component.m_name,
								Prefab = nemesisMinion.PrefabName,
								SpawnGroupSize = Random.Range(nemesisMinion.MinAmount, nemesisMinion.MaxAmount),
								CreatureBaseValueModifiers = nemesisMinion.CreatureBaseValueModifiers,
								CreaturePerLevelValueModifiers = nemesisMinion.CreaturePerLevelValueModifiers
							});
						}
					}
				}
			}
			return list;
		}

		public static DataObjects.NemesisMiniboss GenerateMinibossForBiome(Biome biome)
		{
			//IL_001f: 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_0083: Invalid comparison between Unknown and I4
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			DataObjects.RemoteNemesisSpawnSettings remoteSpawning = NemesisSystemData.SLE_Nemesis_Settings.RemoteSpawning;
			if (remoteSpawning?.BossCandidatesByBiome == null || !remoteSpawning.BossCandidatesByBiome.TryGetValue(biome, out var value) || value == null || value.Count == 0)
			{
				return null;
			}
			DataObjects.NemesisSpawn nemesisSpawn = WeightedSelectCandidate(value);
			if (nemesisSpawn == null)
			{
				Logger.LogNemesis($"No valid remote boss candidate for biome {biome} (missing prefabs?).");
				return null;
			}
			DataObjects.NemesisSpawn nemesisSpawn2 = DataObjects.yamlDeserializer.Deserialize<DataObjects.NemesisSpawn>(DataObjects.yamlSerializer.Serialize((object)nemesisSpawn));
			nemesisSpawn2.IsBoss = true;
			nemesisSpawn2.SpawnGroupSize = 1;
			if ((int)nemesisSpawn2.Faction == 12)
			{
				nemesisSpawn2.Faction = (Faction)8;
			}
			if (string.IsNullOrEmpty(nemesisSpawn2.CustomName))
			{
				nemesisSpawn2.CustomName = RandomlySelectBossName("", include_postfix: false);
			}
			return new DataObjects.NemesisMiniboss
			{
				BossCreatedFromKillingPlayer = false,
				Biome = biome,
				BossSpawn = nemesisSpawn2,
				Minions = GenerateMinionsForBiome(biome)
			};
		}

		private static DataObjects.NemesisSpawn WeightedSelectCandidate(List<DataObjects.NemesisSpawn> candidates)
		{
			List<DataObjects.NemesisSpawn> list = candidates.Where((DataObjects.NemesisSpawn c) => c != null && !string.IsNullOrEmpty(c.Prefab) && (Object)(object)PrefabManager.Instance.GetPrefab(c.Prefab) != (Object)null).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			float num = list.Sum((DataObjects.NemesisSpawn c) => Mathf.Max(0f, c.SelectionWeight));
			if (num <= 0f)
			{
				return list[Random.Range(0, list.Count)];
			}
			float num2 = Random.Range(0f, num);
			foreach (DataObjects.NemesisSpawn item in list)
			{
				num2 -= Mathf.Max(0f, item.SelectionWeight);
				if (num2 <= 0f)
				{
					return item;
				}
			}
			return list[list.Count - 1];
		}
	}
	internal static class NemesisMinimap
	{
		private static readonly Dictionary<string, List<PinData>> pins = new Dictionary<string, List<PinData>>();

		private static readonly Dictionary<string, DataObjects.NemesisBossPin> pending = new Dictionary<string, DataObjects.NemesisBossPin>();

		private static PinType customPinType = (PinType)8;

		private static bool spriteRegistered = false;

		private static bool triedRegister = false;

		internal static void OnMapReady()
		{
			triedRegister = false;
			spriteRegistered = false;
			EnsureSpriteRegistered();
			if (pending.Count <= 0)
			{
				return;
			}
			foreach (DataObjects.NemesisBossPin item in new List<DataObjects.NemesisBossPin>(pending.Values))
			{
				AddOrUpdatePin(item);
			}
			pending.Clear();
		}

		public static void AddOrUpdatePin(DataObjects.NemesisBossPin pin)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if (pin != null && !string.IsNullOrEmpty(pin.Id) && NemesisSystemData.SLE_Nemesis_Settings.RemoteSpawning.ShowMapPin)
			{
				if ((Object)(object)Minimap.instance == (Object)null)
				{
					pending[pin.Id] = pin;
					return;
				}
				RemovePin(pin.Id);
				DataObjects.RemoteNemesisSpawnSettings remoteSpawning = NemesisSystemData.SLE_Nemesis_Settings.RemoteSpawning;
				List<PinData> list = new List<PinData>();
				PinData val = Minimap.instance.AddPin((Vector3)pin.Position, (PinType)13, "", false, false, 0L, default(PlatformUserID));
				val.m_worldSize = remoteSpawning.MapPinAreaRadius * 2f;
				list.Add(val);
				PinType val2 = ResolvePinType();
				string text = ((remoteSpawning.PinShowsBossName && Localization.instance != null) ? Localization.instance.Localize(pin.Name ?? "") : "");
				PinData item = Minimap.instance.AddPin((Vector3)pin.Position, val2, text, false, false, 0L, default(PlatformUserID));
				list.Add(item);
				pins[pin.Id] = list;
			}
		}

		public static void RemovePin(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return;
			}
			pending.Remove(id);
			if (!pins.TryGetValue(id, out var value))
			{
				return;
			}
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				foreach (PinData item in value)
				{
					if (item != null)
					{
						Minimap.instance.RemovePin(item);
					}
				}
			}
			pins.Remove(id);
		}

		public static void ClearAll()
		{
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				foreach (List<PinData> value in pins.Values)
				{
					foreach (PinData item in value)
					{
						if (item != null)
						{
							Minimap.instance.RemovePin(item);
						}
					}
				}
			}
			pins.Clear();
			pending.Clear();
		}

		private static PinType ResolvePinType()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			EnsureSpriteRegistered();
			if (!spriteRegistered)
			{
				return NemesisSystemData.SLE_Nemesis_Settings.RemoteSpawning.FallbackPinType;
			}
			return customPinType;
		}

		private static void EnsureSpriteRegistered()
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			if (triedRegister || (Object)(object)Minimap.instance == (Object)null)
			{
				return;
			}
			triedRegister = true;
			string mapPinSpriteAsset = NemesisSystemData.SLE_Nemesis_Settings.RemoteSpawning.MapPinSpriteAsset;
			if (string.IsNullOrEmpty(mapPinSpriteAsset))
			{
				return;
			}
			Sprite val = null;
			if ((Object)(object)StarLevelSystem.EmbeddedResourceBundle != (Object)null)
			{
				try
				{
					val = StarLevelSystem.EmbeddedResourceBundle.LoadAsset<Sprite>(mapPinSpriteAsset);
				}
				catch (Exception ex)
				{
					Logger.LogWarning("Failed loading Nemesis pin sprite '" + mapPinSpriteAsset + "': " + ex.Message);
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogWarning("Nemesis map pin sprite '" + mapPinSpriteAsset + "' not found; using the fallback pin type.");
				return;
			}
			Minimap instance = Minimap.instance;
			int num = Enum.GetValues(typeof(PinType)).Length + 4;
			customPinType = (PinType)num;
			if (instance.m_visibleIconTypes == null)
			{
				return;
			}
			if (instance.m_visibleIconTypes.Length <= num)
			{
				bool[] array = new bool[num + 1];
				Array.Copy(instance.m_visibleIconTypes, array, instance.m_visibleIconTypes.Length);
				for (int i = instance.m_visibleIconTypes.Length; i < array.Length; i++)
				{
					array[i] = true;
				}
				instance.m_visibleIconTypes = array;
			}
			if (!instance.m_icons.Exists((SpriteData x) => x.m_name == customPinType))
			{
				instance.m_icons.Add(new SpriteData
				{
					m_name = customPinType,
					m_icon = val
				});
			}
			spriteRegistered = true;
		}
	}
	internal static class NemesisPatches
	{
		[HarmonyPatch(typeof(Player))]
		public static class NemesisCreateNemesisFromPlayerKillers
		{
			[HarmonyPatch(typeof(Player), "OnDeath")]
			[HarmonyPostfix]
			public static void PlayerDiedCreateNemesis(Player __instance)
			{
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Expected O, but got Unknown
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				if (NemesisSystemData.SLE_Nemesis_Settings == null || !ValConfig.EnableNemesisSystem.Value || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || !NemesisSystemData.SLE_Nemesis_Settings.CreateMinibossFromPlayerKiller || ((Character)__instance).m_lastHit == null)
				{
					return;
				}
				Character attacker = ((Character)__instance).m_lastHit.GetAttacker();
				if ((Object)(object)attacker == (Object)null || attacker.IsBoss())
				{
					return;
				}
				float num = Random.Range(0f, 1f);
				Logger.LogNemesis($"Rolling for potential Nemesis boss creation {num} <= {NemesisSystemData.SLE_Nemesis_Settings.NemesisBossChance}");
				if (num > NemesisSystemData.SLE_Nemesis_Settings.NemesisBossChance)
				{
					return;
				}
				int forcedLevel = Mathf.Min(ValConfig.MaxLevel.Value, Mathf.RoundToInt((float)attacker.m_level * Random.Range(NemesisSystemData.SLE_Nemesis_Settings.NemesisBossMinLevelBonus, NemesisSystemData.SLE_Nemesis_Settings.NemesisBossMaxLevelBonus)));
				DataObjects.NemesisMiniboss nemesisMiniboss = new DataObjects.NemesisMiniboss();
				nemesisMiniboss.BossSpawn = new DataObjects.NemesisSpawn
				{
					CreatureAI = DataObjects.AI.HuntPlayer,
					ForcedLevel = forcedLevel,
					Faction = (Faction)8,
					Prefab = Utils.GetPrefabName(((Component)attacker).gameObject),
					IsBoss = true,
					CustomName = NemesisMiniBossManager.RandomlySelectBossName(((Character)Player.m_localPlayer).m_name),
					SpawnGroupSize = 1
				};
				nemesisMiniboss.KilledPlayerName = Player.m_localPlayer.GetPlayerName();
				nemesisMiniboss.BossCreatedFromKillingPlayer = true;
				nemesisMiniboss.Biome = Heightmap.FindBiome(((Component)attacker).transform.position);
				nemesisMiniboss.Minions = NemesisMiniBossManager.GenerateMinionsForBiome(nemesisMiniboss.Biome);
				string text = DataObjects.yamlSerializer.Serialize((object)nemesisMiniboss);
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					ValConfig.ApplyNemesisBossAdd(text, ZNet.GetUID());
				}
				else
				{
					ZNet instance = ZNet.instance;
					ZNetPeer val = ((instance != null) ? instance.GetServerPeer() : null);
					if (val != null)
					{
						ZPackage val2 = new ZPackage();
						val2.Write(text);
						ValConfig.SendNewNemesisBossRPC.SendPackage(val.m_uid, val2);
					}
				}
				if (NemesisSystemData.SLE_Nemesis_Settings.CreationRemovesSourceCreature)
				{
					attacker.m_nview.ClaimOwnership();
					ZNetScene.instance.Destroy(((Component)attacker).gameObject);
				}
				Player.MessageAllInRange(((Component)__instance).transform.position, 25f, (MessageType)2, "$SLS_Secret_warning", (Sprite)null);
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		public static class AttachNemesisManagerOnSpawn
		{
			public static void Postfix(Player __instance)
			{
				if (NemesisSystemData.SLE_Nemesis_Settings != null && ValConfig.EnableNemesisSystem.Value)
				{
					NemesisSystem.NemesisManager.Setup(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		public static class TrackPlayerDamage
		{
			public static void Prefix(HitData hit, Character __instance)
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Expected I4, but got Unknown
				if (hit == null || (Object)(object)__instance == (Object)null || !ValConfig.EnableNemesisSystem.Value || NemesisSystemData.SLE_Nemesis_Settings == null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				float totalDamageOptions = hit.GetTotalDamageOptions(include_poison: true, include_spirit: true);
				if (totalDamageOptions <= 0f)
				{
					return;
				}
				Character attacker = hit.GetAttacker();
				if ((Object)(object)attacker == (Object)null || (Object)(object)NemesisSystem.NemesisManager == (Object)null)
				{
					return;
				}
				if ((Object)(object)attacker == (Object)(object)Player.m_localPlayer)
				{
					SkillType skill = hit.m_skill;
					switch (skill - 8)
					{
					case 0:
					case 6:
						NemesisScoreSystem.RecordDamageDealtRanged(totalDamageOptions);
						break;
					case 1:
					case 2:
						NemesisScoreSystem.RecordDamageDealtMagic(totalDamageOptions);
						break;
					default:
						NemesisScoreSystem.RecordDamageDealtMelee(totalDamageOptions);
						break;
					}
				}
				else if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					NemesisScoreSystem.RecordDamageTaken(totalDamageOptions);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "OnDeath")]
		public static class TrackPlayerDeathAndBossKills
		{
			public static void Prefix(Character __instance)
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance == (Object)null) && ValConfig.EnableNemesisSystem.Value && !((Object)(object)Player.m_localPlayer == (Object)null) && NemesisSystemData.SLE_Nemesis_Settings != null)
				{
					if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
					{
						NemesisScoreSystem.PlayerDeathScoreChange(Player.m_localPlayer);
					}
					else if (__instance.IsBoss() && Vector3.Distance(((Component)__instance).transform.position, ((Component)Player.m_localPlayer).transform.position) <= NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.BossKillRadius)
					{
						NemesisScoreSystem.RecordBossKill(((Object)((Component)__instance).gameObject).name.Replace("(Clone)", ""));
					}
				}
			}
		}

		[HarmonyPatch(typeof(Character), "OnDeath")]
		public static class RemoveNemesisBossPinOnDeath
		{
			public static void Prefix(Character __instance)
			{
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Expected O, but got Unknown
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid() || !__instance.m_nview.IsOwner() || __instance.m_nview.GetZDO() == null)
				{
					return;
				}
				string text = __instance.m_nview.GetZDO().GetString(DataObjects.SLS_NEMESIS_PIN, "");
				if (string.IsNullOrEmpty(text))
				{
					return;
				}
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					NemesisRemoteSpawnControl.RemoveActiveBoss(text);
					return;
				}
				ZNet instance = ZNet.instance;
				ZNetPeer val = ((instance != null) ? instance.GetServerPeer() : null);
				if (val != null)
				{
					ZPackage val2 = new ZPackage();
					val2.Write(text);
					ValConfig.ReportNemesisBossDeathRPC.SendPackage(val.m_uid, val2);
				}
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		public static class RegisterNemesisRemoteSpawnerPrefab
		{
			public static void Postfix(ZNetScene __instance)
			{
				NemesisRemoteSpawnControl.EnsureRegisteredToZNetScene();
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "Awake")]
		public static class AttachNemesisRemoteSpawnManager
		{
			public static void Postfix(RandEventSystem __instance)
			{
				if (!((Object)(object)((Component)__instance).GetComponent<NemesisRemoteSpawnManager>() != (Object)null))
				{
					NemesisRemoteSpawnControl.Manager = ((Component)__instance).gameObject.AddComponent<NemesisRemoteSpawnManager>();
					NemesisRemoteSpawnControl.Manager.Setup();
				}
			}
		}
	}
	internal static class NemesisRemoteSpawnControl
	{
		internal const string SpawnerPrefabName = "SLS_NemesisRemoteSpawner";

		internal static GameObject SpawnerPrefab;

		internal static NemesisRemoteSpawnManager Manager;

		private const float PlacementHeightOffset = 100f;

		internal static Dictionary<string, DataObjects.NemesisBossPin> ActiveRemoteBosses = new Dictionary<string, DataObjects.NemesisBossPin>();

		private static readonly int MaxScoutTries = 120;

		internal static void LoadAssets()
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			if ((Object)(object)SpawnerPrefab != (Object)null)
			{
				return;
			}
			GameObject val = StarLevelSystem.EmbeddedResourceBundle.LoadAsset<GameObject>("SLS_NemesisRemoteSpawner.prefab");
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogWarning("[NemesisRemote] LoadAssets: bundle prefab 'SLS_NemesisRemoteSpawner.prefab' NOT FOUND in the asset bundle.");
				return;
			}
			ZNetView component = val.GetComponent<ZNetView>();
			bool flag = (Object)(object)val.GetComponent<NemesisRemoteSpawner>() != (Object)null;
			Logger.LogInfo($"[NemesisRemote] LoadAssets: loaded '{((Object)val).name}' znetview={(Object)(object)component != (Object)null} persistent={(Object)(object)component != (Object)null && component.m_persistent} hasController={flag}");
			if ((Object)(object)component != (Object)null)
			{
				component.m_persistent = true;
			}
			if (!flag)
			{
				val.AddComponent<NemesisRemoteSpawner>();
			}
			if ((Object)(object)PrefabManager.Instance.GetPrefab("SLS_NemesisRemoteSpawner") == (Object)null)
			{
				PrefabManager.Instance.AddPrefab(new CustomPrefab(val, false));
			}
			SpawnerPrefab = PrefabManager.Instance.GetPrefab("SLS_NemesisRemoteSpawner");
			Logger.LogInfo(string.Format("[NemesisRemote] LoadAssets: registered={0} name='{1}'", (Object)(object)SpawnerPrefab != (Object)null, ((Object)(object)SpawnerPrefab != (Object)null) ? ((Object)SpawnerPrefab).name : "null"));
		}

		internal static void EnsureRegisteredToZNetScene()
		{
			LoadAssets();
			if (!((Object)(object)SpawnerPrefab == (Object)null) && !((Object)(object)ZNetScene.instance == (Object)null))
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode("SLS_NemesisRemoteSpawner");
				bool flag = ZNetScene.instance.HasPrefab(stableHashCode);
				if (!flag)
				{
					PrefabManager.Instance.RegisterToZNetScene(SpawnerPrefab);
				}
				Logger.LogInfo($"[NemesisRemote] EnsureRegisteredToZNetScene: znetsceneHadPrefab={flag} nowRegistered={ZNetScene.instance.HasPrefab(stableHashCode)}");
			}
		}

		internal static bool RequestForceSpawn(Biome biome)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected I4, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if (ZNet.instance.IsServer())
			{
				if ((Object)(object)Manager == (Object)null)
				{
					return false;
				}
				Manager.ForceSpawnForBiome(biome);
				return true;
			}
			ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
			if (serverPeer == null)
			{
				return false;
			}
			ZPackage val = new ZPackage();
			val.Write((int)biome);
			ValConfig.ClientRequestNemesisRemoteSpawnRPC.SendPackage(serverPeer.m_uid, val);
			return true;
		}

		internal static void LoadState()
		{
			ActiveRemoteBosses = new Dictionary<string, DataObjects.NemesisBossPin>();
			try
			{
				if (File.Exists(ValConfig.nemesisRemoteStateFilePath))
				{
					Dictionary<string, DataObjects.NemesisBossPin> dictionary = DataObjects.yamlDeserializer.Deserialize<Dictionary<string, DataObjects.NemesisBossPin>>(File.ReadAllText(ValConfig.nemesisRemoteStateFilePath));
					if (dictionary != null)
					{
						ActiveRemoteBosses = dictionary;
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to load Nemesis remote spawn state, starting fresh. " + ex.Message);
				ActiveRemoteBosses = new Dictionary<string, DataObjects.NemesisBossPin>();
			}
		}

		internal static void SaveState()
		{
			try
			{
				ValConfig.GetSavedDataSecondaryConfigDirectoryPath();
				File.WriteAllText(ValConfig.nemesisRemoteStateFilePath, DataObjects.yamlSerializer.Serialize((object)ActiveRemoteBosses));
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to save Nemesis remote spawn state. " + ex.Message);
			}
		}

		internal static void RegisterActiveBoss(DataObjects.NemesisBossPin pin)
		{
			if (pin != null && !string.IsNullOrEmpty(pin.Id))
			{
				ActiveRemoteBosses[pin.Id] = pin;
				SaveState();
			}
		}

		internal static void RemoveActiveBoss(string pinId)
		{
			if (!string.IsNullOrEmpty(pinId))
			{
				if (ActiveRemoteBosses.Remove(pinId))
				{
					SaveState();
				}
				ValConfig.BroadcastNemesisBossPinRemove(pinId);
			}
		}

		internal static void ReconcileFromSpawnerZDOs()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			if (ZDOMan.instance == null)
			{
				return;
			}
			List<ZDO> list = new List<ZDO>();
			int num = 0;
			while (!ZDOMan.instance.GetAllZDOsWithPrefabIterative("SLS_NemesisRemoteSpawner", list, ref num))
			{
			}
			foreach (ZDO item in list)
			{
				if (item != null && item.IsValid())
				{
					string text = item.GetString(DataObjects.SLS_NEMESIS_PIN, "");
					if (!string.IsNullOrEmpty(text) && !ActiveRemoteBosses.ContainsKey(text))
					{
						Vector3 position = item.GetPosition();
						ActiveRemoteBosses[text] = new DataObjects.NemesisBossPin
						{
							Id = text,
							Position = position,
							Biome = Heightmap.FindBiome(position),
							Name = item.GetString(DataObjects.SLS_NAME, "")
						};
					}
				}
			}
		}

		internal static int CountActiveTotal()
		{
			return ActiveRemoteBosses.Count;
		}

		internal static int CountActivePerBiome(Biome biome)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return ActiveRemoteBosses.Values.Count((DataObjects.NemesisBossPin p) => p.Biome == biome);
		}

		internal static List<DataObjects.NemesisBossPin> GetActiveBossPins()
		{
			return ActiveRemoteBosses.Values.ToList();
		}

		internal static void PlaceSpawner(DataObjects.NemesisMiniboss boss, Vector3 groundPoint, Biome biome)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected I4, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (boss == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			string text = Guid.NewGuid().ToString("N");
			string text2 = ((boss.BossSpawn != null) ? boss.BossSpawn.CustomName : "");
			Vector3 val = groundPoint + Vector3.up * 100f;
			if (ZNet.instance.IsDedicated())
			{
				ZNetPeer nearestReadyPeer = SLSExtensions.GetNearestReadyPeer(groundPoint);
				if (nearestReadyPeer == null)
				{
					Logger.LogNemesis($"[NemesisRemote] PlaceSpawner: no ready peer available to host the placeholder for '{boss.BossSpawn?.Prefab}' ({biome}); skipping this cycle.");
					return;
				}
				DataObjects.NemesisRemotePlacementRequest nemesisRemotePlacementRequest = new DataObjects.NemesisRemotePlacementRequest
				{
					Boss = boss,
					Biome = (int)biome,
					PinId = text,
					BossName = text2,
					PlacePos = val
				};
				ZPackage val2 = new ZPackage();
				val2.Write(DataObjects.yamlSerializer.Serialize((object)nemesisRemotePlacementRequest));
				ValConfig.ClientPlaceNemesisSpawnerRPC.SendPackage(nearestReadyPeer.m_uid, val2);
				Logger.LogInfo($"[NemesisRemote] PlaceSpawner: dispatched placeholder for '{boss.BossSpawn?.Prefab}' ({biome}) at {val} to peer {nearestReadyPeer.m_uid} ({nearestReadyPeer.m_playerName}) pin={text}");
			}
			else
			{
				InstantiateSpawnerLocally(boss, val, biome, text, text2);
			}
			DataObjects.NemesisBossPin pin = new DataObjects.NemesisBossPin
			{
				Id = text,
				Position = groundPoint,
				Biome = biome,
				Name = text2
			};
			RegisterActiveBoss(pin);
			if (NemesisSystemData.SLE_Nemesis_Settings.RemoteSpawning.ShowMapPin)
			{
				ValConfig.BroadcastNemesisBossPinAdd(pin);
			}
		}

		internal static void InstantiateSpawnerFromRequest(string yaml)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			DataObjects.NemesisRemotePlacementRequest nemesisRemotePlacementRequest = null;
			try
			{
				nemesisRemotePlacementRequest = DataObjects.yamlDeserializer.Deserialize<DataObjects.NemesisRemotePlacementRequest>(yaml);
			}
			catch (Exception ex)
			{
				Logger.LogWarning("[NemesisRemote] Failed to parse remote placement request: " + ex.Message);
				return;
			}
			if (nemesisRemotePlacementRequest == null || nemesisRemotePlacementRequest.Boss == null)
			{
				Logger.LogWarning("[NemesisRemote] Remote placement request had no boss data; ignoring.");
			}
			else
			{
				InstantiateSpawnerLocally(nemesisRemotePlacementRequest.Boss, nemesisRemotePlacementRequest.PlacePos, (Biome)nemesisRemotePlacementRequest.Biome, nemesisRemotePlacementRequest.PinId, nemesisRemotePlacementRequest.BossName);
			}
		}

		private static void InstantiateSpawnerLocally(DataObjects.NemesisMiniboss boss, Vector3 placePos, Biome biome, string pinId, string bossName)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)SpawnerPrefab == (Object)null)
			{
				Logger.LogWarning("[NemesisRemote] SpawnerPrefab not loaded; cannot instantiate placeholder.");
				return;
			}
			GameObject obj = Object.Instantiate<GameObject>(SpawnerPrefab, placePos, Quaternion.identity);
			obj.GetComponent<NemesisRemoteSpawner>().Setup(boss, biome, pinId, bossName);
			ZNetView component = obj.GetComponent<ZNetView>();
			ZDO val = (((Object)(object)component != (Object)null) ? component.GetZDO() : null);
			Logger.LogDebug($"[NemesisRemote] instantiated placeholder '{((Object)SpawnerPrefab).name}' at {placePos} biome={biome} boss='{boss.BossSpawn?.Prefab}' " + $"zdoValid={val != null && val.IsValid()} persistent={val != null && val.Persistent} owner={val != null && component.IsOwner()} pin={pinId}");
		}

		internal static IEnumerator ScoutBiomeLocation(Biome biome, Action<bool, Vector3> onComplete)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				onComplete?.Invoke(arg1: false, Vector3.zero);
				yield break;
			}
			Tuple<float, float> range = GetBiomeRadiusRange(biome);
			int tries = 0;
			GameObject val = default(GameObject);
			while (tries < MaxScoutTries)
			{
				tries++;
				if (tries % 5 == 0)
				{
					yield return (object)new WaitForSeconds(0.1f);
				}
				Vector3 candidate = SelectWorldPoint(range, tries, biome);
				Vector2i zoneId = ZoneSystem.GetZone(candidate);
				int zoneWait = 0;
				while (!ZoneSystem.instance.SpawnZone(zoneId, (SpawnMode)1, ref val))
				{
					zoneWait++;
					if (zoneWait > 30)
					{
						break;
					}
					yield return (object)new WaitForEndOfFrame();
				}
				if (IsSpawnLocationValid(candidate, biome, out var groundPoint))
				{
					Logger.LogInfo($"[NemesisRemote] scout: found valid {biome} location at {groundPoint} after {tries} tries.");
					onComplete?.Invoke(arg1: true, groundPoint);
					yield break;
				}
			}
			Logger.LogInfo($"[NemesisRemote] scout: exhausted {MaxScoutTries} tries for biome {biome}, no valid location found.");
			onComplete?.Invoke(arg1: false, Vector3.zero);
		}

		private static Tuple<float, float> GetBiomeRadiusRange(Biome biome)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<Biome, DataObjects.BiomeSpawnRadius> biomeRadiusRanges = NemesisSystemData.SLE_Nemesis_Settings.RemoteSpawning.BiomeRadiusRanges;
			if (biomeRadiusRanges != null && biomeRadiusRanges.TryGetValue(biome, out var value))
			{
				return new Tuple<float, float>(value.Min, value.Max);
			}
			return new Tuple<float, float>(500f, 10500f);
		}

		private static Vector3 SelectWorldPoint(Tuple<float, float> range, int intervalRange, Biome biome)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			float item = range.Item1;
			float item2 = range.Item2;
			if ((int)biome == 32 || (int)biome == 64)
			{
				float num = (((int)biome == 32) ? (-1f) : 1f);
				float num2 = Random.Range(item + (float)(intervalRange * 90), item + (float)(intervalRange * 90) + 100f) * num;
				return new Vector3(Random.Range(-1f * (item / 2f), item / 2f), 0f, num2);
			}
			Vector2 val = Random.insideUnitCircle;
			float num3 = Mathf.Lerp(item, item2, ((Vector2)(ref val)).magnitude);
			val *= num3;
			return new Vector3(val.x, 0f, val.y);
		}

		private static bool IsSpawnLocationValid(Vector3 location, Biome targetBiome, out Vector3 groundPoint)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Invalid comparison between Unknown and I4
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Invalid comparison between Unknown and I4
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			groundPoint = location;
			Vector3 val = default(Vector3);
			Biome val2 = default(Biome);
			BiomeArea val3 = default(BiomeArea);
			Heightmap val4 = default(Heightmap);
			ZoneSystem.instance.GetGroundData(ref location, ref val, ref val2, ref val3, ref val4);
			if ((Object)(object)val4 == (Object)null || (int)val2 == 0 || val2 != targetBiome)
			{
				return false;
			}
			float y = location.y;
			float num = default(float);
			if (!ZoneSystem.instance.FindFloor(new Vector3(location.x, location.y + 100f, location.z), ref num))
			{
				return false;
			}
			float num2 = num - y;
			if (num2 > 1f)
			{
				return false;
			}
			if (num2 > 0f)
			{
				location.y = num;
			}
			float waterLevel = ZoneSystem.instance.m_waterLevel;
			if ((int)val2 != 256 && waterLevel > location.y + 2f)
			{
				return false;
			}
			if (location.y < 27f)
			{
				return false;
			}
			if ((int)val2 == 32 && val4.IsLava(location, 0.6f))
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)EffectArea.IsPointInsideArea(location, (Type)4, 0f)))
			{
				return false;
			}
			if (PrivateArea.m_allAreas.Any((PrivateArea a) => a.IsInside(location, 0f)))
			{
				return false;
			}
			location.y += 0.5f;
			groundPoint = location;
			return true;
		}

		internal static void SpawnMinibossGroup(DataObjects.NemesisMiniboss boss, Vector3 point, Biome biome, int extraLevelBonus, string pinId)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (boss == null)
			{
				return;
			}
			List<DataObjects.ExtendedCharacterDrop> value = null;
			NemesisSystemData.SLE_Nemesis_Settings.NemesisBossLootTables?.TryGetValue(biome, out value);
			Quaternion rot = Quaternion.Euler(0f, Random.Range(0f, 360f), 0f);
			Logger.LogInfo($"[NemesisRemote] SpawnMinibossGroup at {point} biome={biome} boss='{boss.BossSpawn?.Prefab}' minions={boss.Minions?.Count ?? 0} biomeLoot={value?.Count ?? 0}");
			if (boss.Minions != null)
			{
				foreach (DataObjects.NemesisSpawn minion in boss.Minions)
				{
					SpawnNemesisSpawn(minion, point, rot, extraLevelBonus, value, null);
				}
			}
			if (boss.BossSpawn != null)
			{
				SpawnNemesisSpawn(boss.BossSpawn, point, rot, extraLevelBonus, value, pinId);
			}
		}

		internal static void SpawnNemesisSpawn(DataObjects.NemesisSpawn spawn, Vector3 basePoint, Quaternion rot, int levelBonus, List<DataObjects.ExtendedCharacterDrop> extraBiomeLoot, string pinId)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Invalid comparison between Unknown and I4
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			if (spawn == null || string.IsNullOrEmpty(spawn.Prefab))
			{
				return;
			}
			Vector2 val = Random.insideUnitCircle * 0.8f;
			Vector3 val2 = basePoint + new Vector3(val.x, 0f, val.y);
			int num = 0;
			while (num < spawn.SpawnGroupSize)
			{
				num++;
				GameObject prefab = PrefabManager.Instance.GetPrefab(spawn.Prefab);
				if ((Object)(object)prefab == (Object)null)
				{
					Logger.LogWarning("[NemesisRemote] spawn prefab '" + spawn.Prefab + "' not found, skipping.");
					continue;
				}
				GameObject val3 = Object.Instantiate<GameObject>(prefab, val2, rot);
				Character component = val3.GetComponent<Character>();
				if ((Object)(object)component == (Object)null)
				{
					Logger.LogWarning("[NemesisRemote] spawn '" + spawn.Prefab + "' has no Character component, skipping.");
					continue;
				}
				Logger.LogInfo($"[NemesisRemote] instantiated '{spawn.Prefab}' (boss={spawn.IsBoss}) at {val2}");
				if ((int)spawn.Faction != 12)
				{
					component.m_faction = spawn.Faction;
				}
				if (spawn.IsBoss)
				{
					component.m_boss = true;
					component.m_dontHideBossHud = true;
					if ((Object)(object)component.m_nview != (Object)null)
					{
						component.m_nview.GetZDO().Set(DataObjects.SLS_NEMESIS_BOSS, true);
						if (!string.IsNullOrEmpty(pinId))
						{
							component.m_nview.GetZDO().Set(DataObjects.SLS_NEMESIS_PIN, pinId);
						}
					}
				}
				if (!string.IsNullOrEmpty(spawn.CustomName) && (Object)(object)component.m_nview != (Object)null)
				{
					component.m_nview.GetZDO().Set(DataObjects.SLS_NAME, spawn.CustomName);
				}
				MonsterAI component2 = val3.GetComponent<MonsterAI>();
				if ((Object)(object)component2 != (Object)null)
				{
					CreatureSetupControl.ApplySpawnAI(component2, spawn.CreatureAI);
					if (spawn.DespawnIfNotAlerted)
					{
						component2.SetEventCreature(true);
					}
				}
				int num2 = LevelGeneratorResolver.RollLevel(spawn.LevelupGenerators, spawn.LevelupGeneratorRefs);
				int leveloverride = ((num2 > 0) ? num2 : spawn.ForcedLevel);
				Dictionary<string, DataObjects.ModifierType> requiredModifiers = spawn.RequiredModifiers;
				DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(component, leveloverride, requiredModifiers);
				andSetLocalCache.Level = Mathf.Min(levelBonus + andSetLocalCache.Level, ValConfig.MaxLevel.Value);
				if (spawn.CreaturePerLevelValueModifiers != null)
				{
					foreach (KeyValuePair<DataObjects.CreaturePerLevelAttribute, float> creaturePerLevelValueModifier in spawn.CreaturePerLevelValueModifiers)
					{
						andSetLocalCache.CreaturePerLevelValueModifiers[creaturePerLevelValueModifier.Key] = creaturePerLevelValueModifier.Value;
					}
				}
				if (spawn.CreatureBaseValueModifiers != null)
				{
					foreach (KeyValuePair<DataObjects.CreatureBaseAttribute, float> creatureBaseValueModifier in spawn.CreatureBaseValueModifiers)
					{
						andSetLocalCache.CreatureBaseValueModifiers[creatureBaseValueModifier.Key] = creatureBaseValueModifier.Value;
					}
				}
				if (spawn.RequiredModifiers != null && spawn.RequiredModifiers.Count > 0)
				{
					andSetLocalCache.CreatureModifiers = spawn.RequiredModifiers;
					CompositeLazyCache.SetCreatureModifiers(component, spawn.RequiredModifiers);
				}
				CreatureSetupControl.CreatureSetup(component, andSetLocalCache.Level, multiply: true, 0f);
				List<DataObjects.ExtendedCharacterDrop> list = MergeLoot(spawn.CustomLoot, extraBiomeLoot);
				if (list != null && list.Count > 0)
				{
					LootSystemData.SetCustomLoot(component, list);
				}
			}
		}

		private static List<DataObjects.ExtendedCharacterDrop> MergeLoot(List<DataObjects.ExtendedCharacterDrop> primary, List<DataObjects.ExtendedCharacterDrop> extra)
		{
			bool flag = primary != null && primary.Count > 0;
			bool flag2 = extra != null && extra.Count > 0;
			if (!flag && !flag2)
			{
				return null;
			}
			List<DataObjects.ExtendedCharacterDrop> list = new List<DataObjects.ExtendedCharacterDrop>();
			if (flag)
			{
				list.AddRange(primary);
			}
			if (flag2)
			{
				list.AddRange(extra);
			}
			return list;
		}
	}
	internal class NemesisRemoteSpawner : MonoBehaviour
	{
		private ZNetView znv;

		private const string KeyBoss = "SLS_NRS_BOSS";

		private const string KeyBiome = "SLS_NRS_BIOME";

		private const string KeyPlaced = "SLS_NRS_PLACED";

		private const int WarmupTicks = 120;

		private const int NonOwnerClaimTicks = 240;

		private int warmup;

		private int diagTick;

		public void Awake()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			znv = ((Component)this).GetComponent<ZNetView>();
			ZDO val = (((Object)(object)znv != (Object)null) ? znv.GetZDO() : null);
			bool flag = val != null && !string.IsNullOrEmpty(val.GetString("SLS_NRS_BOSS", ""));
			Logger.LogInfo($"[NemesisRemote] spawner Awake at {((Component)this).transform.position} znv={(Object)(object)znv != (Object)null} zdoValid={val != null && val.IsValid()} owner={(Object)(object)znv != (Object)null && znv.IsOwner()} hasBossData={flag}");
		}

		public void OnDestroy()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)znv != (Object)null && znv.IsValid() && znv.GetZDO() != null && znv.GetZDO().GetBool("SLS_NRS_PLACED", false);
			Logger.LogInfo($"[NemesisRemote] spawner OnDestroy at {((Component)this).transform.position} warmup={warmup} placed={flag} (placed=false here means culled while dormant, ZDO persists)");
		}

		public void Setup(DataObjects.NemesisMiniboss boss, Biome biome, string pinId, string bossName)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected I4, but got Unknown
			if ((Object)(object)znv == (Object)null)
			{
				znv = ((Component)this).GetComponent<ZNetView>();
			}
			if (!((Object)(object)znv == (Object)null) && znv.GetZDO() != null)
			{
				znv.GetZDO().Set("SLS_NRS_BOSS", DataObjects.yamlSerializer.Serialize((object)boss));
				znv.GetZDO().Set("SLS_NRS_BIOME", (int)biome);
				znv.GetZDO().Set(DataObjects.SLS_NEMESIS_PIN, pinId ?? "");
				znv.GetZDO().Set(DataObjects.SLS_NAME, bossName ?? "");
				znv.GetZDO().Set("SLS_NRS_PLACED", false);
			}
		}

		public void Update()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)znv == (Object)null || !znv.IsValid())
			{
				Diag("znv null/invalid");
			}
			else if ((Object)(object)ZNetScene.instance == (Object)null || !ZNetScene.instance.IsAreaReady(((Component)this).transform.position))
			{
				Diag("area not ready");
			}
			else if (!znv.IsOwner())
			{
				if (warmup < 240)
				{
					if (warmup == 0)
					{
						object arg = ((Component)this).transform.position;
						ZDO zDO = znv.GetZDO();
						Logger.LogInfo($"[NemesisRemote] spawner loaded but not owner at {arg} (owner={((zDO != null) ? new long?(zDO.GetOwner()) : ((long?)null))}); grace period before claiming.");
					}
					warmup++;
				}
				else
				{
					object arg2 = ((Component)this).transform.position;
					ZDO zDO2 = znv.GetZDO();
					Logger.LogInfo($"[NemesisRemote] spawner claiming ownership at {arg2} (owner was {((zDO2 != null) ? new long?(zDO2.GetOwner()) : ((long?)null))}).");
					znv.ClaimOwnership();
				}
			}
			else if (warmup < 120)
			{
				if (warmup == 0)
				{
					Logger.LogInfo($"[NemesisRemote] spawner ready (owner + area ready) at {((Component)this).transform.position}, warming up {120} ticks.");
				}
				warmup++;
			}
			else
			{
				Logger.LogInfo($"[NemesisRemote] spawner warmup complete at {((Component)this).transform.position}, spawning boss now.");
				SpawnAndDestroy();
			}
		}

		private void Diag(string reason)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			diagTick++;
			if (diagTick % 180 == 1)
			{
				Logger.LogInfo($"[NemesisRemote] spawner waiting at {((Component)this).transform.position}: {reason}");
			}
		}

		private void SpawnAndDestroy()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			string text = znv.GetZDO().GetString("SLS_NRS_BOSS", "");
			DataObjects.NemesisMiniboss nemesisMiniboss = null;
			if (!string.IsNullOrEmpty(text))
			{
				try
				{
					nemesisMiniboss = DataObjects.yamlDeserializer.Deserialize<DataObjects.NemesisMiniboss>(text);
				}
				catch (Exception ex)
				{
					Logger.LogWarning("Nemesis remote spawner failed to read its boss data: " + ex.Message);
				}
			}
			Biome val = (Biome)znv.GetZDO().GetInt("SLS_NRS_BIOME", 0);
			string pinId = znv.GetZDO().GetString(DataObjects.SLS_NEMESIS_PIN, "");
			Vector3 position = ((Component)this).transform.position;
			float y = default(float);
			if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.FindFloor(((Component)this).transform.position, ref y))
			{
				position.y = y;
			}
			if (nemesisMiniboss != null)
			{
				NemesisRemoteSpawnControl.SpawnMinibossGroup(nemesisMiniboss, position, val, 0, pinId);
				Logger.LogNemesis($"Remote spawner materialized boss '{nemesisMiniboss.BossSpawn?.CustomName}' ({val}) at {position}");
			}
			else
			{
				Logger.LogWarning("Nemesis remote spawner had no boss data; destroying without spawning.");
			}
			znv.GetZDO().Set("SLS_NRS_PLACED", true);
			DestroySelf();
		}

		private void DestroySelf()
		{
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				znv.ClaimOwnership();
				ZNetScene.instance.Destroy(((Component)this).gameObject);
			}
		}
	}
	public class NemesisRemoteSpawnManager : MonoBehaviour
	{
		private bool setup;

		private bool forceRun;

		private double nextCheckTime;

		private int pendingScouts;

		public void Awake()
		{
			((MonoBehaviour)this).InvokeRepeating("CheckRemoteSpawns", 60f, 60f);
		}

		public void Setup()
		{
			NemesisRemoteSpawnControl.LoadState();
			NemesisRemoteSpawnControl.ReconcileFromSpawnerZDOs();
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				nextCheckTime = ZNet.instance.GetTimeSeconds() + 120.0;
			}
			setup = true;
		}

		public void CheckRemoteSpawns()
		{
			if (!setup || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || !ValConfig.EnableNemesisRemoteSpawning.Value)
			{
				return;
			}
			DataObjects.RemoteNemesisSpawnSettings remoteNemesisSpawnSettings = NemesisSystemData.SLE_Nemesis_Settings?.RemoteSpawning;
			if (remoteNemesisSpawnSettings == null || !remoteNemesisSpawnSettings.Enabled)
			{
				return;
			}
			double timeSeconds = ZNet.instance.GetTimeSeconds();
			float num = Mathf.Max(60f, remoteNemesisSpawnSettings.CheckIntervalMinutes * 60f);
			if (forceRun || !(timeSeconds < nextCheckTime))
			{
				nextCheckTime = timeSeconds + (double)num;
				forceRun = false;
				if (ZNet.instance.GetNrOfPlayers() > 0)
				{
					RunSpawnCycle(remoteNemesisSpawnSettings);
				}
			}
		}

		private void RunSpawnCycle(DataObjects.RemoteNemesisSpawnSettings settings)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			NemesisRemoteSpawnControl.ReconcileFromSpawnerZDOs();
			if (NemesisRemoteSpawnControl.CountActiveTotal() + pendingScouts >= settings.MaxConcurrentTotal || settings.TargetPerBiome == null || settings.TargetPerBiome.Count == 0)
			{
				return;
			}
			List<Biome> list = new List<Biome>();
			foreach (KeyValuePair<Biome, int> item in settings.TargetPerBiome)
			{
				int num = NemesisRemoteSpawnControl.CountActivePerBiome(item.Key);
				int num2 = int.MaxValue;
				if (settings.MaxConcurrentPerBiome != null && settings.MaxConcurrentPerBiome.TryGetValue(item.Key, out var value))
				{
					num2 = value;
				}
				if (num < item.Value && num < num2)
				{
					list.Add(item.Key);
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			list = list.ShuffleList();
			int num3 = settings.MaxSpawnsPerInterval;
			foreach (Biome item2 in list)
			{
				if (num3 <= 0 || NemesisRemoteSpawnControl.CountActiveTotal() + pendingScouts >= settings.MaxConcurrentTotal)
				{
					break;
				}
				DataObjects.NemesisMiniboss nemesisMiniboss = SelectOrGenerateBoss(item2);
				if (nemesisMiniboss == null)
				{
					Logger.LogNemesis($"No pool or generated boss available for biome {item2}, skipping.");
					continue;
				}
				num3--;
				pendingScouts++;
				((MonoBehaviour)this).StartCoroutine(ScoutAndPlace(item2, nemesisMiniboss));
			}
		}

		private DataObjects.NemesisMiniboss SelectOrGenerateBoss(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			DataObjects.NemesisMiniboss nemesisMiniboss = NemesisMiniBossManager.RandomlySelectAppropriateMiniboss(biome);
			if (nemesisMiniboss != null)
			{
				ValConfig.ApplyNemesisBossRemove(DataObjects.yamlSerializer.Serialize((object)nemesisMiniboss), ZNet.GetUID());
				return nemesisMiniboss;
			}
			return NemesisMiniBossManager.GenerateMinibossForBiome(biome);
		}

		private IEnumerator ScoutAndPlace(Biome biome, DataObjects.NemesisMiniboss boss)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			bool success = false;
			Vector3 point = Vector3.zero;
			yield return NemesisRemoteSpawnControl.ScoutBiomeLocation(biome, delegate(bool ok, Vector3 p)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				success = ok;
				point = p;
			});
			pendingScouts = Mathf.Max(0, pendingScouts - 1);
			if (success)
			{
				NemesisRemoteSpawnControl.PlaceSpawner(boss, point, biome);
			}
			else
			{
				Logger.LogNemesis($"Remote scout failed for biome {biome}; boss not placed this cycle.");
			}
		}

		public void ForceSpawnForBiome(Biome biome)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			DataObjects.NemesisMiniboss nemesisMiniboss = SelectOrGenerateBoss(biome);
			if (nemesisMiniboss == null)
			{
				Logger.LogInfo($"[NemesisRemote] Could not select or generate a Nemesis boss for biome {biome}.");
				return;
			}
			Logger.LogInfo($"[NemesisRemote] DebugSpawnForBiome {biome}: selected boss '{nemesisMiniboss.BossSpawn?.Prefab}' (level {nemesisMiniboss.BossSpawn?.ForcedLevel}); scouting a location...");
			((MonoBehaviour)this).StartCoroutine(ScoutAndPlace(biome, nemesisMiniboss));
		}

		public void ForceRun()
		{
			forceRun = true;
		}
	}
	internal static class NemesisScoreSystem
	{
		public static float GetScore(Player player)
		{
			float num = NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.MaxScore * 0.5f;
			if ((Object)(object)player == (Object)null || (Object)(object)((Character)player).m_nview == (Object)null)
			{
				return num;
			}
			ZDO zDO = ((Character)player).m_nview.GetZDO();
			if (zDO == null)
			{
				return num;
			}
			return zDO.GetFloat(DataObjects.SLS_NEMESIS_SCORE, num);
		}

		public static void SetScore(Player player, float s)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)((Character)player).m_nview == (Object)null))
			{
				float num = Mathf.Clamp(s, NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.MinScore, NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.MaxScore);
				ZDO zDO = ((Character)player).m_nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set(DataObjects.SLS_NEMESIS_SCORE, num);
					NemesisSystem.CachedPlayerScore = num;
				}
			}
		}

		public static float UpdateScore(Player player, float change)
		{
			float num = NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.MaxScore * 0.5f;
			if ((Object)(object)player == (Object)null || (Object)(object)((Character)player).m_nview == (Object)null)
			{
				return num;
			}
			ZDO zDO = ((Character)player).m_nview.GetZDO();
			if (zDO == null)
			{
				return NemesisSystem.CachedPlayerScore;
			}
			float num2 = Mathf.Clamp(zDO.GetFloat(DataObjects.SLS_NEMESIS_SCORE, num) + change, NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.MinScore, NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.MaxScore);
			zDO.Set(DataObjects.SLS_NEMESIS_SCORE, num2);
			NemesisSystem.CachedPlayerScore = num2;
			return num2;
		}

		internal static Tuple<float, float, float> DamageTrendCalculation(DataObjects.DamageScoreData dsd_recent, int historyLengthUsed = 3)
		{
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			for (int i = 0; historyLengthUsed > i && i < NemesisSystem.PlayerScore.DamageScoreHistory.Count; i++)
			{
				DataObjects.DamageScoreData damageScoreData = NemesisSystem.PlayerScore.DamageScoreHistory[i];
				num += damageScoreData.DamageDealtMelee;
				num2 += damageScoreData.DamageDealtRanged;
				num3 += damageScoreData.DamageTaken;
			}
			if (num > 0f && historyLengthUsed > 0)
			{
				num /= (float)historyLengthUsed;
			}
			if (num2 > 0f && historyLengthUsed > 0)
			{
				num2 /= (float)historyLengthUsed;
			}
			if (num3 > 0f && historyLengthUsed > 0)
			{
				num3 /= (float)historyLengthUsed;
			}
			return Tuple.Create(num, num2, num3);
		}

		public static void UpdateScore(Player player)
		{
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)((Character)player).m_nview == (Object)null || ((Character)player).m_nview.GetZDO() == null || NemesisSystem.PlayerScore == null)
			{
				return;
			}
			DataObjects.NemesisScore cfg = NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem;
			DataObjects.DamageScoreData damageScoreData = new DataObjects.DamageScoreData
			{
				DamageDealtMelee = NemesisSystem.PlayerScore.DamageDealtMelee,
				DamageDealtRanged = NemesisSystem.PlayerScore.DamageDealtRanged,
				DamageDealtMagic = NemesisSystem.PlayerScore.DamageDealtMagic,
				DamageTaken = NemesisSystem.PlayerScore.DamageTaken
			};
			DamageTrendCalculation(damageScoreData, cfg.DamageScoreHistoryLength).Deconstruct(out var item, out var item2, out var item3);
			float num = item;
			float num2 = item2;
			float num3 = item3;
			float score = GetScore(player);
			score += num * cfg.MeleeDamageDealtFactor + num2 * cfg.RangedDamageDealtFactor + NemesisSystem.PlayerScore.DamageDealtMagic * cfg.MagicDamageDealtFactor;
			score -= num3 * cfg.DamageTakenFactor;
			score += (float)NemesisSystem.PlayerScore.BossKills * cfg.BossKillBonus;
			score = ((!(score > cfg.NeutralScore)) ? (score + cfg.DecayPerUpdate) : (score - cfg.DecayPerUpdate));
			List<Player> list = (from p in SLSExtensions.GetPlayersInRange(((Component)player).transform.position, cfg.NearbyPlayerRadius)
				where (Object)(object)p != (Object)null && (Object)(object)p != (Object)(object)player && (Object)(object)((Character)p).m_nview != (Object)null && ((Character)p).m_nview.GetZDO() != null
				select p).ToList();
			if (list.Count > 0)
			{
				float num4 = list.Average((Player p) => ((Character)p).m_nview.GetZDO().GetFloat(DataObjects.SLS_NEMESIS_SCORE, cfg.NeutralScore));
				score = Mathf.Lerp(score, num4, cfg.NearbyAveragingWeight);
			}
			score = Mathf.Clamp(score, cfg.MinScore, cfg.MaxScore);
			SetScore(player, score);
			NemesisSystem.CachedPlayerScore = score;
			NemesisSystem.PlayerScore.DamageScoreHistory.Insert(0, damageScoreData);
			while (NemesisSystem.PlayerScore.DamageScoreHistory.Count > cfg.DamageScoreHistoryLength)
			{
				NemesisSystem.PlayerScore.DamageScoreHistory.RemoveAt(NemesisSystem.PlayerScore.DamageScoreHistory.Count - 1);
			}
			SaveScoreData(player);
			if (ValConfig.EnableDebugMode.Value)
			{
				Logger.LogNemesis($"Nemesis recalc: score={GetScore(player):0.0} dealtΔ(dmg)={num:0.0}/{num2:0.0} takenΔ(dmg)={num3:0.0} bossΔ(kills)={NemesisSystem.PlayerScore.BossKills} peers={list.Count}");
			}
			NemesisSystem.PlayerScore.DamageDealtMelee = 0f;
			NemesisSystem.PlayerScore.DamageDealtRanged = 0f;
			NemesisSystem.PlayerScore.DamageDealtMagic = 0f;
			NemesisSystem.PlayerScore.DamageTaken = 0f;
			NemesisSystem.PlayerScore.BossKills = 0;
		}

		public static void RecordBossKill(string prefabName)
		{
			if (NemesisSystem.PlayerScore != null && !string.IsNullOrEmpty(prefabName))
			{
				if (!NemesisSystem.PlayerScore.BossKillsHistory.ContainsKey(prefabName))
				{
					NemesisSystem.PlayerScore.BossKillsHistory.Add(prefabName, 1);
				}
				else
				{
					NemesisSystem.PlayerScore.BossKillsHistory[prefabName]++;
				}
				SaveScoreData(Player.m_localPlayer);
			}
		}

		internal static void LoadScoreData(Player player)
		{
			NemesisSystem.PlayerScore = null;
			if (player.m_customData != null && player.m_customData.TryGetValue(DataObjects.SLS_NEMESIS_SCOREDATA, out var value) && !string.IsNullOrEmpty(value))
			{
				try
				{
					NemesisSystem.PlayerScore = DataObjects.yamlDeserializer.Deserialize<DataObjects.ScoreData>(value);
				}
				catch (Exception ex)
				{
					Logger.LogWarning("Nemesis ScoreData failed to deserialize, resetting: " + ex.Message);
					NemesisSystem.PlayerScore = null;
				}
			}
			if (NemesisSystem.PlayerScore == null)
			{
				NemesisSystem.PlayerScore = new DataObjects.ScoreData();
			}
		}

		internal static void SaveScoreData(Player player)
		{
			if (!((Object)(object)player == (Object)null) && player.m_customData != null && NemesisSystem.PlayerScore != null)
			{
				player.m_customData[DataObjects.SLS_NEMESIS_SCOREDATA] = DataObjects.yamlSerializerJsonCompat.Serialize((object)NemesisSystem.PlayerScore);
			}
		}

		public static void PlayerDeathScoreChange(Player player)
		{
			if (!((Object)(object)NemesisSystem.NemesisManager == (Object)null))
			{
				NemesisSystem.PlayerScore.LastDeath = ZNet.instance.GetTimeSeconds();
				SaveScoreData(player);
				SetScore(player, GetScore(player) - NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.DeathScoreReduction);
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					NemesisSystem.NemesisManager.nextRecalcTime = ZNet.instance.GetTimeSeconds() + (double)NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.ScoreIntervalSeconds;
				}
			}
		}

		internal static void RecordDamageDealtMelee(float amt)
		{
			if (NemesisSystem.PlayerScore != null && !(amt <= 0f))
			{
				NemesisSystem.PlayerScore.DamageDealtMelee += amt;
			}
		}

		internal static void RecordDamageDealtRanged(float amt)
		{
			if (NemesisSystem.PlayerScore != null && !(amt <= 0f))
			{
				NemesisSystem.PlayerScore.DamageDealtRanged += amt;
			}
		}

		internal static void RecordDamageDealtMagic(float amt)
		{
			if (NemesisSystem.PlayerScore != null && !(amt <= 0f))
			{
				NemesisSystem.PlayerScore.DamageDealtMagic += amt;
			}
		}

		internal static void RecordDamageTaken(float amt)
		{
			if (NemesisSystem.PlayerScore != null && !(amt <= 0f))
			{
				NemesisSystem.PlayerScore.DamageTaken += amt;
			}
		}

		internal static void UpdatePlayerRecentBiomes()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			NemesisSystem.PlayerRecentBiomes.Add(Heightmap.FindBiome(((Component)Player.m_localPlayer).transform.position));
			if (NemesisSystem.PlayerRecentBiomes.Count > NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.RecentBiomeHistoryLength)
			{
				while (NemesisSystem.PlayerRecentBiomes.Count > NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.RecentBiomeHistoryLength)
				{
					NemesisSystem.PlayerRecentBiomes.RemoveAt(0);
				}
			}
		}

		internal static int PlayerRecentBiomeCount(Biome biome)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return NemesisSystem.PlayerRecentBiomes.Count((Biome b) => b == biome);
		}
	}
}
namespace StarLevelSystem.modules.Modifiers
{
	public static class CreatureModifiers
	{
		internal static readonly string NoMods = "None";

		internal static GameObject VisualEffectHolder = new GameObject("SLS_Visuals");

		private static readonly List<DataObjects.NameSelectionStyle> prefixSelectors = new List<DataObjects.NameSelectionStyle>
		{
			DataObjects.NameSelectionStyle.RandomFirst,
			DataObjects.NameSelectionStyle.RandomBoth
		};

		private static readonly List<DataObjects.NameSelectionStyle> suffixSelectors = new List<DataObjects.NameSelectionStyle>
		{
			DataObjects.NameSelectionStyle.RandomLast,
			DataObjects.NameSelectionStyle.RandomBoth
		};

		public static void RunOnceModifierSetup(Character character, DataObjects.CharacterCacheEntry cacheEntry)
		{
			if (cacheEntry.CreatureModifiers == null || cacheEntry.RunOnceDone)
			{
				return;
			}
			int num = 0;
			foreach (KeyValuePair<string, DataObjects.ModifierType> creatureModifier in cacheEntry.CreatureModifiers)
			{
				if (ValConfig.LimitCreatureModifiersToCreatureStarLevel.Value && num >= character.m_level - 1)
				{
					break;
				}
				if (!(creatureModifier.Key == NoMods) && !(creatureModifier.Key == string.Empty))
				{
					switch (creatureModifier.Value)
					{
					case DataObjects.ModifierType.Boss:
						RunOnceModifier(creatureModifier.Key, character, cacheEntry, CreatureModifiersData.ActiveCreatureModifiers.BossModifiers);
						break;
					case DataObjects.ModifierType.Major:
						RunOnceModifier(creatureModifier.Key, character, cacheEntry, CreatureModifiersData.ActiveCreatureModifiers.MajorModifiers);
						break;
					case DataObjects.ModifierType.Minor:
						RunOnceModifier(creatureModifier.Key, character, cacheEntry, CreatureModifiersData.ActiveCreatureModifiers.MinorModifiers);
						break;
					}
					num++;
				}
			}
			cacheEntry.RunOnceDone = true;
		}

		public static void SetupModifiers(Character character, DataObjects.CharacterCacheEntry cacheEntry, Dictionary<string, DataObjects.ModifierType> selectedMods)
		{
			if (selectedMods == null)
			{
				return;
			}
			int num = 0;
			foreach (KeyValuePair<string, DataObjects.ModifierType> selectedMod in selectedMods)
			{
				if (ValConfig.LimitCreatureModifiersToCreatureStarLevel.Value && num >= character.m_level - 1)
				{
					break;
				}
				if (!(selectedMod.Key == NoMods) && !(selectedMod.Key == string.Empty))
				{
					switch (selectedMod.Value)
					{
					case DataObjects.ModifierType.Boss:
						StartupModifier(selectedMod.Key, character, cacheEntry, CreatureModifiersData.ActiveCreatureModifiers.BossModifiers);
						break;
					case DataObjects.ModifierType.Major:
						StartupModifier(selectedMod.Key, character, cacheEntry, CreatureModifiersData.ActiveCreatureModifiers.MajorModifiers);
						break;
					case DataObjects.ModifierType.Minor:
						StartupModifier(selectedMod.Key, character, cacheEntry, CreatureModifiersData.ActiveCreatureModifiers.MinorModifiers);
						break;
					}
					num++;
				}
			}
		}

		private static void RunOnceModifier(string mod, Character character, DataObjects.CharacterCacheEntry cacheEntry, Dictionary<string, DataObjects.CreatureModifierConfiguration> availableMods)
		{
			if (!availableMods.ContainsKey(mod))
			{
				if (!(mod == NoMods))
				{
					Logger.LogWarning("Modifier " + mod + " not found in CreatureModifiersData, skipping runonce setup for " + ((Object)character).name);
				}
			}
			else
			{
				DataObjects.CreatureModifierConfiguration creatureModifierConfiguration = availableMods[mod];
				CreatureModifiersData.ModifierDefinitions[mod].RunOnceMethodCall(character, creatureModifierConfiguration.Config, cacheEntry);
			}
		}

		private static void StartupModifier(string mod, Character character, DataObjects.CharacterCacheEntry cacheEntry, Dictionary<string, DataObjects.CreatureModifierConfiguration> availableMods)
		{
			if (!availableMods.ContainsKey(mod))
			{
				if (!(mod == NoMods))
				{
					Logger.LogWarning("Modifier " + mod + " not found in CreatureModifiersData, skipping setup for " + ((Object)character).name);
				}
			}
			else
			{
				DataObjects.CreatureModifierConfiguration creatureModifierConfiguration = availableMods[mod];
				CreatureModifiersData.ModifierDefinitions[mod].SetupMethodCall(character, creatureModifierConfiguration.Config, cacheEntry);
				SetupCreatureVFX(character, CreatureModifiersData.ModifierDefinitions[mod]);
			}
		}

		internal static void SetupCreatureVFX(Character character, DataObjects.CreatureModifierDefinition creatureModifier)
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || creatureModifier == null || creatureModifier.VisualEffect == null)
			{
				return;
			}
			GameObject val = CreatureModifiersData.LoadedModifierEffects[creatureModifier.VisualEffect];
			if ((Object)(object)val == (Object)null || Object.op_Implicit((Object)(object)((Component)character).transform.Find("SLS_Visuals(Clone)/" + ((Object)val).name + "(Clone)")))
			{
				return;
			}
			Transform val2 = ((Component)character).transform.Find("SLS_Visuals(Clone)");
			if ((Object)(object)val2 == (Object)null)
			{
				if ((Object)(object)VisualEffectHolder == (Object)null || (Object)(object)((Component)character).gameObject == (Object)null)
				{
					return;
				}
				val2 = Object.Instantiate<GameObject>(VisualEffectHolder, ((Component)character).transform).transform;
			}
			GameObject val3 = Object.Instantiate<GameObject>(val, val2);
			if (!((Object)(object)val3 == (Object)null))
			{
				float height = character.GetHeight();
				float num = height / 5f;
				float num2 = character.GetRadius() / 2f;
				switch (creatureModifier.VisualEffectStyle)
				{
				case DataObjects.VisualEffectStyle.top:
					val3.transform.localPosition = new Vector3(0f, height, 0f);
					break;
				case DataObjects.VisualEffectStyle.bottom:
					val3.transform.localPosition = new Vector3(0f, 0f, 0f);
					break;
				case DataObjects.VisualEffectStyle.objectCenter:
					val3.transform.localPosition = new Vector3(0f, height / 2f, 0f);
					break;
				}
				val3.transform.localScale = new Vector3(val3.transform.localScale.x * num, val3.transform.localScale.y * num2, val3.transform.localScale.z * num);
			}
		}

		internal static GameObject ApplySecondaryVFX(string effectName, Vector3 position, Quaternion rotation)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (CreatureModifiersData.LoadedSecondaryEffects.ContainsKey(effectName))
			{
				GameObject val = CreatureModifiersData.LoadedSecondaryEffects[effectName];
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				return Object.Instantiate<GameObject>(val, position, rotation);
			}
			return null;
		}

		internal static string BuildCreatureLocalizableName(Character chara, Dictionary<string, DataObjects.ModifierType> modifiers)
		{
			if (!chara.m_nview.IsValid())
			{
				return chara.m_name;
			}
			if (modifiers == null)
			{
				modifiers = new Dictionary<string, DataObjects.ModifierType>();
			}
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			int num = 0;
			int num2 = 1;
			List<string> list3 = modifiers.Keys.ToList();
			if (ValConfig.MinorModifiersFirstInName.Value)
			{
				list3 = (from kvp in modifiers
					orderby kvp.Value
					select kvp.Key).Reverse().ToList();
			}
			foreach (string item in list3)
			{
				if ((ValConfig.LimitCreatureModifiersToCreatureStarLevel.Value && num >= chara.m_level - 1) || list3.Count <= 0 || num >= list3.Count)
				{
					break;
				}
				num++;
				if (item == NoMods)
				{
					continue;
				}
				if (modifiers.ContainsKey(item))
				{
					_ = modifiers[item];
				}
				DataObjects.CreatureModifierDefinition creatureModifierDefinition = CreatureModifiersData.ModifierDefinitions[item];
				if (creatureModifierDefinition != null)
				{
					if (num2 <= ValConfig.LimitCreatureModifierPrefixes.Value && prefixSelectors.Contains(creatureModifierDefinition.NamingConvention) && creatureModifierDefinition.NamePrefix != null && creatureModifierDefinition.NamePrefix.Length > 0)
					{
						num2++;
						list.Add(creatureModifierDefinition.NamePrefix);
					}
					else if (suffixSelectors.Contains(creatureModifierDefinition.NamingConvention) && creatureModifierDefinition.NameSuffix != null && creatureModifierDefinition.NameSuffix.Length > 0)
					{
						list2.Add(creatureModifierDefinition.NameSuffix);
					}
				}
			}
			string text = chara.m_name;
			string text2 = chara.m_nview.GetZDO().GetString(DataObjects.SLS_NAME, "");
			if (!string.IsNullOrEmpty(text2))
			{
				text = text2;
			}
			if (list.Count == 0 && list2.Count == 0)
			{
				return text;
			}
			string text3 = string.Join(" ", list) + " " + text;
			if (list2.Count > 0)
			{
				text3 = text3 + " $suffix_moniker " + string.Join(" ", list2);
			}
			return text3;
		}

		public static Dictionary<string, DataObjects.ModifierType> SelectModifiersForCreature(Character character, string creatureName, DataObjects.CreatureSpecificSetting creature_settings, Biome biome, int level, Dictionary<string, DataObjects.ModifierType> requiredModifiers = null, List<string> notAllowedModifiers = null)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, DataObjects.ModifierType> result = new Dictionary<string, DataObjects.ModifierType>();
			if (!character.IsPlayer())
			{
				if (character.IsBoss() && ValConfig.EnableBossModifiers.Value)
				{
					int maxBossMods = ValConfig.MaxBossModifiersPerBoss.Value;
					if (creature_settings != null && creature_settings.MaxBossModifiers > -1)
					{
						maxBossMods = creature_settings.MaxBossModifiers;
					}
					float chanceBossMods = ValConfig.ChanceOfBossModifier.Value;
					if (creature_settings != null && creature_settings.ChanceForBossModifier > -1f)
					{
						chanceBossMods = creature_settings.ChanceForBossModifier;
					}
					result = SelectModifiers(character, creatureName, biome, level, 0, 1f, 0, 1f, isBoss: true, maxBossMods, chanceBossMods, requiredModifiers, notAllowedModifiers);
				}
				else
				{
					int num = ValConfig.MaxMajorModifiersPerCreature.Value;
					if (creature_settings != null && creature_settings.MaxMajorModifiers > -1)
					{
						num = creature_settings.MaxMajorModifiers;
					}
					int num2 = ValConfig.MaxMinorModifiersPerCreature.Value;
					if (creature_settings != null && creature_settings.MaxMinorModifiers > -1)
					{
						num2 = creature_settings.MaxMinorModifiers;
					}
					float chanceMajorMods = ValConfig.ChanceMajorModifier.Value;
					if (creature_settings != null && creature_settings.ChanceForMajorModifier > -1f)
					{
						chanceMajorMods = creature_settings.ChanceForMajorModifier;
					}
					float chanceMinorMods = ValConfig.ChanceMinorModifier.Value;
					if (creature_settings != null && creature_settings.ChanceForMinorModifier > -1f)
					{
						chanceMinorMods = creature_settings.ChanceForMinorModifier;
					}
					int maxMajorMods = num;
					int maxMinorMods = num2;
					result = SelectModifiers(character, creatureName, biome, level, maxMajorMods, chanceMajorMods, maxMinorMods, chanceMinorMods, isBoss: false, 0, 1f, requiredModifiers, notAllowedModifiers);
				}
			}
			return result;
		}

		public static Dictionary<string, DataObjects.ModifierType> SelectModifiers(Character character, string creatureName, Biome biome, int level, int maxMajorMods = 0, float chanceMajorMods = 1f, int maxMinorMods = 0, float chanceMinorMods = 1f, bool isBoss = false, int maxBossMods = 0, float chanceBossMods = 1f, Dictionary<string, DataObjects.ModifierType> requiredModifiers = null, List<string> notAllowedModifiers = null)
		{
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, DataObjects.ModifierType> dictionary = new Dictionary<string, DataObjects.ModifierType>();
			if (creatureName != null && CreatureModifiersData.ActiveCreatureModifiers.ModifierGlobalSettings != null && CreatureModifiersData.ActiveCreatureModifiers.ModifierGlobalSettings.GlobalIgnorePrefabList != null && CreatureModifiersData.ActiveCreatureModifiers.ModifierGlobalSettings.GlobalIgnorePrefabList.Contains(((Object)character).name))
			{
				Logger.LogDebug("Creature " + creatureName + " is in the global ignore prefab list, skipping modifier assignment.");
				if (!dictionary.ContainsKey(NoMods))
				{
					dictionary.Add(NoMods, DataObjects.ModifierType.Minor);
				}
				return dictionary;
			}
			if (requiredModifiers == null)
			{
				requiredModifiers = new Dictionary<string, DataObjects.ModifierType>();
			}
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			foreach (KeyValuePair<string, DataObjects.ModifierType> requiredModifier in requiredModifiers)
			{
				switch (requiredModifier.Value)
				{
				case DataObjects.ModifierType.Minor:
					list3.Add(requiredModifier.Key);
					break;
				case DataObjects.ModifierType.Major:
					list2.Add(requiredModifier.Key);
					break;
				case DataObjects.ModifierType.Boss:
					list.Add(requiredModifier.Key);
					break;
				}
			}
			if (isBoss)
			{
				foreach (string item in SelectCreatureModifiers(creatureName, biome, chanceBossMods, maxBossMods, level, 0, DataObjects.ModifierType.Boss, list, notAllowedModifiers))
				{
					if (!dictionary.ContainsKey(item))
					{
						dictionary.Add(item.ToString(), DataObjects.ModifierType.Boss);
					}
				}
				return dictionary;
			}
			List<string> list4 = SelectCreatureModifiers(creatureName, biome, chanceMajorMods, maxMajorMods, level, 0, DataObjects.ModifierType.Major, list2, notAllowedModifiers);
			foreach (string item2 in list4)
			{
				if (!dictionary.ContainsKey(item2))
				{
					dictionary.Add(item2.ToString(), DataObjects.ModifierType.Major);
				}
			}
			foreach (string item3 in SelectCreatureModifiers(creatureName, biome, chanceMinorMods, maxMinorMods, level, list4.Count, DataObjects.ModifierType.Minor, list3, notAllowedModifiers))
			{
				if (!dictionary.ContainsKey(item3))
				{
					dictionary.Add(item3.ToString(), DataObjects.ModifierType.Minor);
				}
			}
			return dictionary;
		}

		public static List<string> SelectCreatureModifiers(string creature, Biome biome, float chance, int num_mods, int level, int existingMods = 0, DataObjects.ModifierType type = DataObjects.ModifierType.Major, List<string> requiredMods = null, List<string> notAllowedModifiers = null)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			if (requiredMods != null)
			{
				list.AddRange(requiredMods);
			}
			List<DataObjects.ProbabilityEntry> list3 = CreatureModifiersData.LazyCacheCreatureModifierSelect(creature, biome, type);
			if (list3.Count == 0)
			{
				return list;
			}
			if (notAllowedModifiers != null)
			{
				list2.AddRange(notAllowedModifiers);
			}
			int i = 0;
			if (requiredMods != null)
			{
				i += requiredMods.Count;
			}
			for (; num_mods > i && (!ValConfig.LimitCreatureModifiersToCreatureStarLevel.Value || i + 1 + existingMods < level); i++)
			{
				if (chance < 1f)
				{
					if (Random.value < chance)
					{
						string item = RandomSelect.RandomSelectFromWeightedListWithExclusions(list3, list2);
						list.Add(item);
						list2.Add(item);
					}
				}
				else
				{
					string item2 = RandomSelect.RandomSelectFromWeightedListWithExclusions(list3, list2);
					list.Add(item2);
					list2.Add(item2);
				}
			}
			if (list.Count == 0)
			{
				list.Add(NoMods);
			}
			return list;
		}

		public static void RemoveCreatureModifier(Character character, string modifier)
		{
			Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(character);
			if (Enumerable.Contains(creatureModifiers.Keys, modifier))
			{
				Logger.LogDebug(((Object)character).name + " has " + modifier + ", removing.");
				if (creatureModifiers.Remove(modifier))
				{
					CompositeLazyCache.SetCreatureModifiers(character, creatureModifiers);
				}
				UIHudControl.InvalidateCacheEntry(character);
			}
		}

		public static bool AddCreatureModifier(Character character, DataObjects.ModifierType modType, string newModifier, bool applyChanges = true)
		{
			if (newModifier == NoMods || newModifier == string.Empty)
			{
				Logger.LogDebug("No modifier specified to add to " + ((Object)character).name + ", skipping.");
				return false;
			}
			Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(character);
			if (creatureModifiers.Count > 0 && creatureModifiers.ContainsKey(newModifier))
			{
				Logger.LogDebug(((Object)character).name + " already has " + newModifier + ", skipping.");
				return false;
			}
			creatureModifiers.Add(newModifier, modType);
			CompositeLazyCache.SetCreatureModifiers(character, creatureModifiers);
			DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(character);
			DataObjects.CreatureModifierConfiguration modifierDef = CreatureModifiersData.GetModifierDef(newModifier, modType);
			CreatureModifiersData.ModifierDefinitions[newModifier].SetupMethodCall(character, modifierDef.Config, cacheEntry);
			CreatureModifiersData.ModifierDefinitions[newModifier].RunOnceMethodCall(character, modifierDef.Config, cacheEntry);
			SetupCreatureVFX(character, CreatureModifiersData.ModifierDefinitions[newModifier]);
			UIHudControl.InvalidateCacheEntry(character);
			if (!applyChanges)
			{
				SpeedModifications.ApplySpeedModifications(character, cacheEntry);
				DamageModifications.ApplyDamageModification(character, cacheEntry);
				SizeModifications.SetSizeModification(((Component)character).gameObject, character.m_nview, cacheEntry, update: true);
				HealthModifications.ForceApplyHealthModifications(character, cacheEntry);
				return true;
			}
			return true;
		}
	}
	internal class Visible_Toggle
	{
		[HarmonyPatch(typeof(Character), "SetVisible")]
		private static class Patch_Character_SetVisible
		{
			internal static readonly string SLSVISUALS = "SLS_Visuals(Clone)";

			private static void Postfix(Character __instance, bool visible)
			{
				Transform val = ((Component)__instance).transform.Find(SLSVISUALS);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(visible);
				}
			}
		}
	}
}
namespace StarLevelSystem.modules.Loot
{
	internal static class LootPatches
	{
		[HarmonyPatch(typeof(CharacterDrop))]
		public static class DropItemsPerformancePatch
		{
			[HarmonyPatch("DropItems")]
			public static bool Prefix(CharacterDrop __instance, List<KeyValuePair<GameObject, int>> drops, Vector3 centerPos, float dropArea)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				LootPerformanceChanges.DropItemsPreferAsync(centerPos, LootPerformanceChanges.DropItemsDetermineDropStackSize(drops), immediate: false, dropThatCharacterDrop: true, drops);
				return false;
			}
		}

		[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
		[HarmonyPriority(0)]
		public static class ModifyLootPerLevelEffect
		{
			public static bool Prefix(ref List<KeyValuePair<GameObject, int>> __result, CharacterDrop __instance)
			{
				if ((Object)(object)__instance.m_character == (Object)null)
				{
					return true;
				}
				string prefabName = Utils.GetPrefabName(((Component)__instance.m_character).gameObject);
				List<DataObjects.ExtendedCharacterDrop> customLoot = LootSystemData.GetCustomLoot(__instance.m_character);
				DataObjects.LootSettings sLS_Drop_Settings = LootSystemData.SLS_Drop_Settings;
				bool flag = sLS_Drop_Settings != null && sLS_Drop_Settings.CharacterSpecificLoot?.ContainsKey(prefabName) == true;
				if (customLoot == null && !flag)
				{
					return true;
				}
				__result = LootStyles.ModifyCharacterDrops(__instance, prefabName, customLoot);
				return false;
			}
		}

		[HarmonyPatch(typeof(CharacterDrop))]
		public static class CalculateLootPerLevelStyle
		{
			[HarmonyTranspiler]
			[HarmonyPatch("GenerateDropList")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Expected O, but got Unknown
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Expected O, but got Unknown
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Expected O, but got Unknown
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Expected O, but got Unknown
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Expected O, but got Unknown
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Expected O, but got Unknown
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(CharacterDrop), "m_character"), (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null)
				}).Advance(2).RemoveInstructions(15)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Func<Character, int>>((Func<Character, int>)DetermineLootScale) })
					.ThrowIfNotMatch("Unable to patch Character drop generator, level scaling.", Array.Empty<CodeMatch>())
					.MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
					{
						new CodeMatch((OpCode?)OpCodes.Ldloc_3, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(Drop), "m_levelMultiplier"), (string)null)
					})
					.Advance(1)
					.MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
					{
						new CodeMatch((OpCode?)OpCodes.Ldloc_3, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(Drop), "m_levelMultiplier"), (string)null)
					})
					.Advance(2)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Func<bool, bool>>((Func<bool, bool>)OverrideLootScalingEnabler) })
					.MatchStartForward((CodeMatch[])(object)new CodeMatch[3]
					{
						new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldc_I4_S, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ble, (object)null, (string)null)
					})
					.Advance(3)
					.RemoveInstructions(2)
					.ThrowIfNotMatch("Unable to patch Character drop limit removal.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			private static bool OverrideLootScalingEnabler(bool defaultlootLevelMultiplier)
			{
				if (ValConfig.ScaleAllLootByLevel.Value)
				{
					return true;
				}
				return defaultlootLevelMultiplier;
			}

			private static int DetermineLootScale(Character character)
			{
				if ((Object)(object)character == (Object)null)
				{
					return 1;
				}
				int level = character.GetLevel();
				if (level <= 1)
				{
					return 1;
				}
				LootStyles.SelectCharacterLootSettings(character, out var distance_bonus);
				float num;
				float num2;
				if (LootStyles.SelectedLootFactor == DataObjects.LootFactorType.PerLevel)
				{
					num = (float)level * (distance_bonus.MinAmountScaleFactorBonus + ValConfig.PerLevelLootScale.Value);
					num2 = (float)level * (distance_bonus.MaxAmountScaleFactorBonus + ValConfig.PerLevelLootScale.Value);
				}
				else if (LootStyles.SelectedLootFactor == DataObjects.LootFactorType.Exponential)
				{
					num = Mathf.Pow(ValConfig.PerLevelLootScale.Value + distance_bonus.MinAmountScaleFactorBonus, (float)level);
					num2 = Mathf.Pow(ValConfig.PerLevelLootScale.Value + distance_bonus.MaxAmountScaleFactorBonus, (float)level);
				}
				else if (LootStyles.SelectedLootFactor == DataObjects.LootFactorType.ChancePerLevel)
				{
					num = 1f;
					num2 = 1f;
				}
				else
				{
					num = (float)level * ValConfig.PerLevelLootScale.Value;
					num2 = (float)level * ValConfig.PerLevelLootScale.Value;
				}
				int num3 = Mathf.RoundToInt(Random.Range(num, num2));
				if (num3 < 1)
				{
					num3 = 1;
				}
				if (ValConfig.EnableDebugLootDetails.Value)
				{
					Logger.LogDebug($"Loot Factor {LootStyles.SelectedLootFactor} | lvl {level} select {num} <-> {num2} selected {num3}.");
				}
				return num3;
			}
		}

		[HarmonyPatch]
		public static class MineRockPerformancePatch
		{
			[HarmonyTranspiler]
			[HarmonyPatch(typeof(MineRock), "RPC_Hit")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Expected O, but got Unknown
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(MineRock), "m_dropItems"), (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(DropTable), "GetDropList", (Type[])null, (Type[])null), (string)null)
				}).RemoveInstructions(6).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_2, (object)null),
					Transpilers.EmitDelegate<Action<MineRock, HitData>>((Action<MineRock, HitData>)ModifyMinerockDrops)
				})
					.RemoveInstructions(30)
					.ThrowIfNotMatch("Unable to patch Minerock performance increase.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			internal static void ModifyMinerockDrops(MineRock instance, HitData hit)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				List<DataObjects.LootEntry> optimizeDrops = LootStyles.ModifyRockDropsOrDefault(((Component)instance).transform, instance.m_dropItems, Utils.GetPrefabName(((Component)instance).gameObject), LevelSelection.DeterministicDetermineRockLevel(((Component)instance).gameObject.transform.position));
				Vector3 position = hit.m_point - hit.m_dir * 0.2f + Random.insideUnitSphere * 0.3f;
				position.y += 0.5f;
				LootPerformanceChanges.DropItemsPreferAsync(position, optimizeDrops);
			}
		}

		[HarmonyPatch(typeof(MineRock5))]
		public static class MineRock5performancePatch
		{
			[HarmonyTranspiler]
			[HarmonyPatch("DamageArea")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, generator);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(DropTable), "GetDropList", (Type[])null, (Type[])null), (string)null)
				}).Advance(1).RemoveInstructions(27)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
					{
						new CodeInstruction(OpCodes.Ldloc_3, (object)null),
						Transpilers.EmitDelegate<Action<MineRock5, Vector3>>((Action<MineRock5, Vector3>)MineDrop)
					})
					.ThrowIfNotMatch("Unable to patch MineRock5 to handle large drops.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			internal static void MineDrop(MineRock5 instance, Vector3 vector)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				int level = LevelSelection.DeterministicDetermineRockLevel(vector);
				List<DataObjects.LootEntry> optimizeDrops = LootStyles.ModifyRockDropsOrDefault(((Component)instance).transform, instance.m_dropItems, Utils.GetPrefabName(((Component)instance).gameObject), level);
				LootPerformanceChanges.DropItemsPreferAsync(vector, optimizeDrops);
			}
		}

		[HarmonyPatch(typeof(DropOnDestroyed))]
		public static class DropItemsNonCharacterPerformancePatch
		{
			[HarmonyTranspiler]
			[HarmonyPatch("OnDestroyed")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Expected O, but got Unknown
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(DropTable), "GetDropList", (Type[])null, (Type[])null), (string)null),
					new CodeMatch((OpCode?)OpCodes.Stloc_2, (object)null, (string)null)
				}).Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					Transpilers.EmitDelegate<Action<DropOnDestroyed>>((Action<DropOnDestroyed>)DropItemsOnDestroy),
					new CodeInstruction(OpCodes.Ret, (object)null)
				})
					.ThrowIfNotMatch("Unable to patch DropOnDestroy to handle large drops.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			private static void DropItemsOnDestroy(DropOnDestroyed instance)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				int level = LevelSelection.DetermineisticDetermineObjectLevel(((Component)instance).transform.position);
				LootStyles.SelectObjectDistanceBonus(((Component)instance).transform, out var distance_bonus);
				List<DataObjects.LootEntry> optimizeDrops = LootStyles.ModifyObjectDropsOrDefault(instance.m_dropWhenDestroyed, Utils.GetPrefabName(((Component)instance).gameObject), level, distance_bonus, DataObjects.DropType.Destructible);
				LootPerformanceChanges.DropItemsPreferAsync(((Component)instance).transform.position, optimizeDrops);
			}
		}

		[HarmonyPatch(typeof(TreeBase))]
		public static class DropItemsTreeBasePerformancePatch
		{
			[HarmonyTranspiler]
			[HarmonyPatch("RPC_Damage")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Expected O, but got Unknown
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(DropTable), "GetDropList", (Type[])null, (Type[])null), (string)null)
				}).Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<TreeBase>>((Action<TreeBase>)TreebaseDropDestroyedItems) })
					.RemoveInstructions(54)
					.Insert((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null)
					})
					.ThrowIfNotMatch("Unable to patch Treebase to handle large drops.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			private static void TreebaseDropDestroyedItems(TreeBase instance)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				List<DataObjects.LootEntry> optimizeDrops = LootStyles.ModifyTreeDropsOrDefault(instance);
				LootPerformanceChanges.DropItemsPreferAsync(((Component)instance).transform.position, optimizeDrops);
			}
		}

		[HarmonyPatch(typeof(Pickable))]
		public static class PickableDropPatch
		{
			[HarmonyTranspiler]
			[HarmonyPatch("RPC_Pick")]
			[HarmonyEmitIL(".dumps")]
			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Expected O, but got Unknown
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Expected O, but got Unknown
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Expected O, but got Unknown
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(Pickable), "m_dontScale"), (string)null)
				}).ThrowIfNotMatch("Unable to patch Pickable drop: drop calculation start not found.", Array.Empty<CodeMatch>());
				int pos = val.Pos;
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(Pickable), "m_extraDrops"), (string)null)
				}).ThrowIfNotMatch("Unable to patch Pickable drop: extra-drops section not found.", Array.Empty<CodeMatch>());
				int pos2 = val.Pos;
				val.Start().Advance(pos).RemoveInstructions(pos2 - pos)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Ldarg_2, (object)null),
						Transpilers.EmitDelegate<Action<Pickable, int>>((Action<Pickable, int>)HandlePickableDrop)
					});
				return val.Instructions();
			}

			internal static void HandlePickableDrop(Pickable instance, int bonus)
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				string prefabName = Utils.GetPrefabName(((Component)instance).gameObject);
				if (LootSystemData.SLS_Drop_Settings != null && LootSystemData.SLS_Drop_Settings.NonCharacterSpecificLoot != null && LootSystemData.SLS_Drop_Settings.NonCharacterSpecificLoot.ContainsKey(prefabName))
				{
					Vector3 position = ((Component)instance).transform.position + Vector3.up * instance.m_spawnOffset;
					List<DataObjects.LootEntry> optimizeDrops = LootStyles.ModifyPickableDropsOrDefault(level: LevelSelection.DetermineisticDetermineObjectLevel(((Component)instance).transform.position), tform: ((Component)instance).transform, name: prefabName);
					LootPerformanceChanges.DropItemsPreferAsync(position, optimizeDrops);
					return;
				}
				int num = (instance.m_dontScale ? instance.m_amount : Mathf.Max(instance.m_minAmountScaled, Game.instance.ScaleDrops(instance.m_itemPrefab, instance.m_amount)));
				num += bonus;
				int num2 = 0;
				for (int i = 0; i < num; i++)
				{
					instance.Drop(instance.m_itemPrefab, num2++, 1);
				}
			}
		}
	}
	internal class LootPerformanceChanges
	{
		public static void DropItemsPreferAsync(Vector3 position, List<DataObjects.LootEntry> optimizeDrops, bool immediate = false, bool dropThatCharacterDrop = false, List<KeyValuePair<GameObject, int>> characterDropSource = null)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!immediate)
			{
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(DropItemsAsync(optimizeDrops, position, 0.5f, dropThatCharacterDrop, characterDropSource));
			}
			else
			{
				DropItemsImmediate(optimizeDrops, position, 0.5f, dropThatCharacterDrop, characterDropSource);
			}
		}

		public static List<DataObjects.LootEntry> DropItemsDetermineDropStackSize(List<KeyValuePair<GameObject, int>> drops, bool dropIndividuals = false)
		{
			List<DataObjects.LootEntry> list = new List<DataObjects.LootEntry>();
			int maxAmountPerDrop = 1;
			for (int i = 0; i < drops.Count; i++)
			{
				KeyValuePair<GameObject, int> keyValuePair = drops[i];
				if (!dropIndividuals)
				{
					ItemDrop component = keyValuePair.Key.GetComponent<ItemDrop>();
					if ((Object)(object)component != (Object)null)
					{
						maxAmountPerDrop = component.m_itemData.m_shared.m_maxStackSize;
					}
				}
				list.Add(new DataObjects.LootEntry
				{
					Amount = keyValuePair.Value,
					Prefab = keyValuePair.Key,
					MaxAmountPerDrop = maxAmountPerDrop,
					ReferenceIndex = i
				});
			}
			return list;
		}

		public static int CheckItemStackingConfig(ItemDrop id, DataObjects.DropType dropType)
		{
			if ((Object)(object)id == (Object)null)
			{
				return 1;
			}
			int num = 2;
			switch (dropType)
			{
			case DataObjects.DropType.Rock:
				if (!ValConfig.RockLootDropsStacked.Value)
				{
					num = 1;
				}
				break;
			case DataObjects.DropType.Tree:
				if (!ValConfig.TreeLootDropsStacked.Value)
				{
					num = 1;
				}
				break;
			case DataObjects.DropType.Destructible:
				if (!ValConfig.MiscLootDropsStacked.Value)
				{
					num = 1;
				}
				break;
			case DataObjects.DropType.Item:
				if (!ValConfig.CreatureLootDropStacked.Value)
				{
					num = 1;
				}
				break;
			}
			if (num == 2)
			{
				return id.m_itemData.m_shared.m_maxStackSize;
			}
			return num;
		}

		private static void DropItemsImmediate(List<DataObjects.LootEntry> drops, Vector3 centerPos, float dropArea, bool dropThatCharacterDrop = false, List<KeyValuePair<GameObject, int>> characterDropSource = null)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			foreach (DataObjects.LootEntry drop in drops)
			{
				if (ValConfig.EnableDebugLootDetails.Value)
				{
					Logger.LogDebug($"Dropping {((Object)drop.Prefab).name} {drop.Amount}");
				}
				int num;
				for (int i = 0; i < drop.Amount; i += num)
				{
					int maxAmountPerDrop = drop.MaxAmountPerDrop;
					GameObject val = Object.Instantiate<GameObject>(drop.Prefab, centerPos, Quaternion.identity);
					num = 1;
					if (maxAmountPerDrop > 1)
					{
						ItemDrop component = val.GetComponent<ItemDrop>();
						if (component != null)
						{
							int num2 = Mathf.Min(drop.Amount - i, maxAmountPerDrop);
							component.m_itemData.m_stack = num2;
							component.m_itemData.m_worldLevel = (byte)Game.m_worldLevel;
							num = num2;
						}
						else
						{
							Character component2 = val.GetComponent<Character>();
							if ((Object)(object)component2 == (Object)null)
							{
								component2 = (Character)(object)val.GetComponent<Humanoid>();
							}
							if ((Object)(object)component2 != (Object)null)
							{
								CompositeLazyCache.GetAndSetLocalCache(component2);
								CreatureSetupControl.CreatureSetup(component2, 0, multiply: false);
							}
						}
					}
					if (dropThatCharacterDrop && characterDropSource != null && Compatibility.IsDropThatEnabled && Compatibility.DropThatCharacterModifyAvailable)
					{
						Compatibility.DropThat_ModifyCharacterDrop(val, characterDropSource, drop.ReferenceIndex);
					}
					Rigidbody component3 = val.GetComponent<Rigidbody>();
					if (Object.op_Implicit((Object)(object)component3))
					{
						Vector3 val2 = Random.insideUnitSphere * dropArea;
						if (val2.y < 0f)
						{
							val2.y = 0f - val2.y;
						}
						component3.AddForce(val2 * 5f, (ForceMode)2);
					}
				}
			}
		}

		private static IEnumerator DropItemsAsync(List<DataObjects.LootEntry> drops, Vector3 centerPos, float dropArea, bool dropThatCharacterDrop = false, List<KeyValuePair<GameObject, int>> characterDropSource = null)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			int obj_spawns = 0;
			foreach (DataObjects.LootEntry drop in drops)
			{
				int max_stack_size = drop.MaxAmountPerDrop;
				if (ValConfig.EnableDebugLootDetails.Value)
				{
					Logger.LogDebug($"Dropping async {((Object)drop.Prefab).name} {drop.Amount}");
				}
				int num;
				for (int i = 0; i < drop.Amount; i += num)
				{
					if (obj_spawns > 0 && obj_spawns % ValConfig.LootDropsPerTick.Value == 0)
					{
						yield return (object)new WaitForSeconds(0.1f);
					}
					GameObject val = Object.Instantiate<GameObject>(drop.Prefab, centerPos, Quaternion.identity);
					obj_spawns++;
					num = 1;
					if (max_stack_size > 1)
					{
						ItemDrop component = val.GetComponent<ItemDrop>();
						if (component != null)
						{
							int num2 = Mathf.Min(drop.Amount - i, max_stack_size);
							component.m_itemData.m_stack = num2;
							component.m_itemData.m_worldLevel = (byte)Game.m_worldLevel;
							num = num2;
						}
						else
						{
							Character component2 = val.GetComponent<Character>();
							if ((Object)(object)component2 == (Object)null)
							{
								component2 = (Character)(object)val.GetComponent<Humanoid>();
							}
							if ((Object)(object)component2 != (Object)null)
							{
								CreatureSetupControl.CreatureSetup(component2, 0, multiply: true, 0.5f);
							}
						}
					}
					if (dropThatCharacterDrop && characterDropSource != null && Compatibility.IsDropThatEnabled && Compatibility.DropThatCharacterModifyAvailable)
					{
						Compatibility.DropThat_ModifyCharacterDrop(val, characterDropSource, drop.ReferenceIndex);
					}
					Rigidbody component3 = val.GetComponent<Rigidbody>();
					if (Object.op_Implicit((Object)(object)component3))
					{
						Vector3 val2 = Random.insideUnitSphere * dropArea;
						if (val2.y < 0f)
						{
							val2.y = 0f - val2.y;
						}
						component3.AddForce(val2 * 5f, (ForceMode)2);
					}
				}
			}
		}
	}
	internal static class LootStyles
	{
		public static DataObjects.LootFactorType SelectedLootFactor = DataObjects.LootFactorType.PerLevel;

		internal static readonly AcceptableValueList<string> AllowedLootFactors = new AcceptableValueList<string>(new string[3]
		{
			DataObjects.LootFactorType.PerLevel.ToString(),
			DataObjects.LootFactorType.Exponential.ToString(),
			DataObjects.LootFactorType.ChancePerLevel.ToString()
		});

		internal static void ParseLootFactor()
		{
			SelectedLootFactor = (DataObjects.LootFactorType)Enum.Parse(typeof(DataObjects.LootFactorType), ValConfig.LootDropCalculationType.Value);
		}

		internal static void LootFactorChanged(object s, EventArgs e)
		{
			ParseLootFactor();
		}

		internal static List<DataObjects.LootEntry> ModifyTreeDropsOrDefault(TreeBase treeInstance)
		{
			int orAddCachedTreeEntry = CompositeLazyCache.GetOrAddCachedTreeEntry(treeInstance.m_nview);
			SelectObjectDistanceBonus(((Component)treeInstance).transform, out var distance_bonus);
			return ModifyObjectDropsOrDefault(treeInstance.m_dropWhenDestroyed, Utils.GetPrefabName(((Component)treeInstance).gameObject), orAddCachedTreeEntry, distance_bonus);
		}

		internal static List<DataObjects.LootEntry> ModifyTreeDropsOrDefault(TreeLog treeInstance)
		{
			int orAddCachedTreeEntry = CompositeLazyCache.GetOrAddCachedTreeEntry(treeInstance.m_nview);
			SelectObjectDistanceBonus(((Component)treeInstance).transform, out var distance_bonus);
			return ModifyObjectDropsOrDefault(treeInstance.m_dropWhenDestroyed, Utils.GetPrefabName(((Component)treeInstance).gameObject), orAddCachedTreeEntry, distance_bonus);
		}

		internal static List<DataObjects.LootEntry> ModifyRockDropsOrDefault(Transform tform, DropTable droptable, string name, int level)
		{
			SelectObjectDistanceBonus(tform, out var distance_bonus);
			return ModifyObjectDropsOrDefault(droptable, name, level, distance_bonus, DataObjects.DropType.Rock);
		}

		internal static List<DataObjects.LootEntry> ModifyPickableDropsOrDefault(Transform tform, string name, int level)
		{
			SelectObjectDistanceBonus(tform, out var distance_bonus);
			return ModifyObjectDropsOrDefault(null, name, level, distance_bonus, DataObjects.DropType.Destructible, tform, honorOnePerPlayer: true);
		}

		internal static List<DataObjects.LootEntry> ModifyObjectDropsOrDefault(DropTable defaultDrops, string lookupkey, int level, DataObjects.DistanceLootModifier distance_bonus, DataObjects.DropType type = DataObjects.DropType.Tree, Transform tform = null, bool honorOnePerPlayer = false)
		{
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Expected O, but got Unknown
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			List<DataObjects.LootEntry> list = new List<DataObjects.LootEntry>();
			bool value = ValConfig.EnableDebugLootDetails.Value;
			StringBuilder stringBuilder = new StringBuilder();
			if (LootSystemData.SLS_Drop_Settings != null && LootSystemData.SLS_Drop_Settings.NonCharacterSpecificLoot != null && LootSystemData.SLS_Drop_Settings.NonCharacterSpecificLoot.ContainsKey(lookupkey))
			{
				if (value)
				{
					stringBuilder.AppendLine($"Custom loot table for {lookupkey} (level {level}):");
				}
				foreach (DataObjects.ExtendedObjectDrop item in LootSystemData.SLS_Drop_Settings.NonCharacterSpecificLoot[lookupkey])
				{
					if (item.Drop.Chance < 1f)
					{
						float value2 = Random.value;
						float num = item.Drop.Chance;
						float num2 = item.ChanceScaleFactor;
						if (SelectedLootFactor == DataObjects.LootFactorType.PerLevel)
						{
							num2 += ValConfig.PerLevelLootChanceScale.Value;
						}
						if (num2 > 0f)
						{
							num *= 1f + num2 * (float)level;
						}
						if (value2 > num)
						{
							if (value)
							{
								stringBuilder.AppendLine($"Drop {item.Drop.Prefab} failed random drop chance ({value2} > {num}).");
							}
							continue;
						}
					}
					if ((Object)(object)item.DropGo == (Object)null)
					{
						item.ResolveDropPrefab();
						if ((Object)(object)item.DropGo == (Object)null)
						{
							Logger.LogWarning("Prefab " + item.Drop.Prefab + " was not found, ensure it is spelled correctly and available in the game. This lootdrop will be skipped.");
							continue;
						}
					}
					int maxAmountPerDrop = LootPerformanceChanges.CheckItemStackingConfig(item.DropGo.GetComponent<ItemDrop>(), type);
					if (item.Drop.DontScale)
					{
						int num3 = Random.Range(item.Drop.Min, item.Drop.Max);
						if (value)
						{
							stringBuilder.AppendLine($"Drop {item.Drop.Prefab}: does not scale, base {num3} from range [{item.Drop.Min}..{item.Drop.Max}).");
						}
						if (honorOnePerPlayer && item.Drop.OnePerPlayer && (Object)(object)tform != (Object)null)
						{
							int num4 = Mathf.Max(1, Player.GetPlayersInRangeXZ(tform.position, 500f));
							if (value)
							{
								stringBuilder.AppendLine($"  onePerPlayer: {num3} * {num4} players = {num3 * num4}.");
							}
							num3 *= num4;
						}
						if (value)
						{
							stringBuilder.AppendLine($"=> {item.Drop.Prefab} final amount {num3}.");
						}
						list.Add(new DataObjects.LootEntry
						{
							Prefab = item.DropGo,
							Amount = num3,
							MaxAmountPerDrop = maxAmountPerDrop
						});
						continue;
					}
					float num5 = 1f;
					int min = item.Drop.Min;
					int max = item.Drop.Max;
					int num6 = min;
					if (min != max)
					{
						num6 = Random.Range(min, max);
						if (value)
						{
							stringBuilder.AppendLine($"Rolling base drop {item.Drop.Prefab} {min}<->{max} result:{num6}.");
						}
					}
					if (item.UseChanceAsMultiplier)
					{
						num5 = item.Drop.Chance * (float)level;
						if (value)
						{
							stringBuilder.AppendLine($"  chance-as-multiplier: chance {item.Drop.Chance} * level {level} = {num5}.");
						}
					}
					int num7 = num6;
					float num8 = item.AmountScaleFactor * num5;
					if (num8 <= 0f)
					{
						num8 = 1f;
					}
					if (value)
					{
						stringBuilder.AppendLine($"  scaleFactor {num8} (amountScaleFactor {item.AmountScaleFactor} * chanceMult {num5}); factor {SelectedLootFactor}, level {level}, distanceBonus min {distance_bonus.MinAmountScaleFactorBonus}/max {distance_bonus.MaxAmountScaleFactorBonus}.");
					}
					switch (SelectedLootFactor)
					{
					case DataObjects.LootFactorType.PerLevel:
						num7 = MultiplyLootPerLevel(num7, level, distance_bonus, num8, value ? stringBuilder : null);
						break;
					case DataObjects.LootFactorType.Exponential:
						num7 = ExponentLootPerLevel(num7, level, distance_bonus, num8, value ? stringBuilder : null);
						break;
					case DataObjects.LootFactorType.ChancePerLevel:
						num7 = ChancePerLevel(num7, level, distance_bonus, num8, value ? stringBuilder : null);
						break;
					}
					if (item.MaxScaledAmount > 0 && num7 > item.MaxScaledAmount)
					{
						if (value)
						{
							stringBuilder.AppendLine($"  capped {num7} -> {item.MaxScaledAmount} (MaxScaledAmount).");
						}
						num7 = item.MaxScaledAmount;
					}
					if (honorOnePerPlayer && item.Drop.OnePerPlayer && (Object)(object)tform != (Object)null)
					{
						int num9 = Mathf.Max(1, Player.GetPlayersInRangeXZ(tform.position, 500f));
						if (value)
						{
							stringBuilder.AppendLine($"  onePerPlayer: {num7} * {num9} players = {num7 * num9}.");
						}
						num7 *= num9;
					}
					if (value)
					{
						stringBuilder.AppendLine($"=> {item.Drop.Prefab} final amount {num7}.");
					}
					list.Add(new DataObjects.LootEntry
					{
						Prefab = item.DropGo,
						Amount = num7,
						MaxAmountPerDrop = maxAmountPerDrop
					});
				}
			}
			else
			{
				if (defaultDrops == null)
				{
					return list;
				}
				DropTable val = new DropTable();
				switch (type)
				{
				case DataObjects.DropType.Tree:
					if (value)
					{
						stringBuilder.AppendLine($"Default Tree drop table for {lookupkey} (level {level}):");
					}
					val = UpdateDropTableByLevel(defaultDrops, level, ValConfig.PerLevelTreeLootScale.Value);
					break;
				case DataObjects.DropType.Rock:
					if (value)
					{
						stringBuilder.AppendLine($"Default Rock drop table for {lookupkey} (level {level}):");
					}
					val = UpdateDropTableByLevel(defaultDrops, level, ValConfig.PerLevelMineRockLootScale.Value);
					break;
				case DataObjects.DropType.Destructible:
					if (value)
					{
						stringBuilder.AppendLine($"Default Destructible drop table for {lookupkey} (level {level}):");
					}
					val = UpdateDropTableByLevel(defaultDrops, level, ValConfig.PerLevelDestructibleLootScale.Value);
					break;
				}
				list = OptimizeToDropStacks(val.GetDropList(), type);
			}
			if (value)
			{
				foreach (DataObjects.LootEntry item2 in list)
				{
					stringBuilder.AppendLine($"  -> {Utils.GetPrefabName(item2.Prefab)} x{item2.Amount} (max {item2.MaxAmountPerDrop}/stack)");
				}
				Logger.LogLoot($"Generated drops for {lookupkey}:\n{stringBuilder}");
			}
			return list;
		}

		internal static List<KeyValuePair<GameObject, int>> ModifyCharacterDrops(CharacterDrop cdrop, string name, List<DataObjects.ExtendedCharacterDrop> customLoot = null)
		{
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			List<KeyValuePair<GameObject, int>> list = new List<KeyValuePair<GameObject, int>>();
			int num = 1;
			if ((Object)(object)cdrop.m_character != (Object)null)
			{
				num = cdrop.m_character.m_level;
			}
			SelectCharacterLootSettings(cdrop.m_character, out var distance_bonus);
			List<DataObjects.ExtendedCharacterDrop> obj = customLoot ?? LootSystemData.SLS_Drop_Settings.CharacterSpecificLoot[name];
			StringBuilder stringBuilder = new StringBuilder();
			foreach (DataObjects.ExtendedCharacterDrop item in obj)
			{
				if ((Object)(object)cdrop.m_character != (Object)null)
				{
					if (item.UntamedOnlyDrop && cdrop.m_character.IsTamed())
					{
						if (ValConfig.EnableDebugLootDetails.Value)
						{
							stringBuilder.AppendLine("Skipping " + item.Drop.Prefab + ": untamed-only drop on a tamed creature.");
						}
						continue;
					}
					if (item.TamedOnlyDrop && !cdrop.m_character.IsTamed())
					{
						if (ValConfig.EnableDebugLootDetails.Value)
						{
							stringBuilder.AppendLine("Skipping " + item.Drop.Prefab + ": tamed-only drop on an untamed creature.");
						}
						continue;
					}
				}
				if (item.GameDrop == null || (Object)(object)item.GameDrop.m_prefab == (Object)null)
				{
					item.ToCharacterDrop();
					if (item.GameDrop == null || (Object)(object)item.GameDrop.m_prefab == (Object)null)
					{
						Logger.LogWarning("Loot prefab '" + item.Drop?.Prefab + "' for '" + name + "' was not found. Ensure it is spelled correctly and available in the game. This drop will be skipped.");
						continue;
					}
				}
				float num2 = 1f;
				if (item.Drop.Chance < 1f)
				{
					float value = Random.value;
					float num3 = item.Drop.Chance;
					float num4 = item.ChanceScaleFactor;
					if (SelectedLootFactor == DataObjects.LootFactorType.PerLevel)
					{
						num4 += ValConfig.PerLevelLootChanceScale.Value;
					}
					if (num4 > 0f)
					{
						num3 *= 1f + num4 * (float)num;
					}
					if (value > num3)
					{
						if (ValConfig.EnableDebugLootDetails.Value)
						{
							stringBuilder.AppendLine($"Drop {item.Drop.Prefab} failed random drop chance ({value} > {num3}).");
						}
						continue;
					}
				}
				if (item.UseChanceAsMultiplier)
				{
					num2 = item.Drop.Chance * (float)num;
					if (ValConfig.EnableDebugLootDetails.Value)
					{
						stringBuilder.AppendLine($"Drop {item.Drop.Prefab} modified by chance and creature level (scale multiplier now: {num2}).");
					}
				}
				int min = item.Drop.Min;
				int max = item.Drop.Max;
				int num5 = min;
				if (min != max)
				{
					num5 = ((!item.ScalebyMaxLevel) ? Random.Range(min, max) : ((max - min) / ValConfig.MaxLevel.Value * num));
					if (ValConfig.EnableDebugLootDetails.Value)
					{
						stringBuilder.AppendLine($"Drop {item.Drop.Prefab} determined base drop amount: {num5}).");
					}
				}
				if (item.DoesNotScale)
				{
					if (ValConfig.EnableDebugLootDetails.Value)
					{
						stringBuilder.AppendLine($"Drop {item.Drop.Prefab} does not scale and will drop {num5}");
					}
					list.Add(new KeyValuePair<GameObject, int>(item.GameDrop.m_prefab, num5));
					continue;
				}
				int num6 = num5;
				if (!item.DoesNotScale && !item.Drop.DontScale)
				{
					float num7 = item.AmountScaleFactor * num2;
					if (num7 <= 0f)
					{
						num7 = 1f;
					}
					switch (SelectedLootFactor)
					{
					case DataObjects.LootFactorType.PerLevel:
						num6 = MultiplyLootPerLevel(num6, num, distance_bonus, num7);
						break;
					case DataObjects.LootFactorType.Exponential:
						num6 = ExponentLootPerLevel(num6, num, distance_bonus, num7);
						break;
					case DataObjects.LootFactorType.ChancePerLevel:
						num6 = ChancePerLevel(num6, num, distance_bonus, num7);
						break;
					}
					if (ValConfig.EnableDebugLootDetails.Value)
					{
						stringBuilder.AppendLine($"Drop {item.Drop.Prefab} Using {SelectedLootFactor} factor {num7} base {num5} = {num6}");
					}
					if (item.MaxScaledAmount > 0 && num6 > item.MaxScaledAmount)
					{
						num6 = item.MaxScaledAmount;
						Logger.LogLoot($"Drop {item.Drop.Prefab} capped to {num6}");
					}
				}
				if (item.Drop.OnePerPlayer)
				{
					int playersInRangeXZ = Player.GetPlayersInRangeXZ(((Component)cdrop).transform.position, 500f);
					num6 *= Mathf.Max(1, playersInRangeXZ);
				}
				list.Add(new KeyValuePair<GameObject, int>(item.GameDrop.m_prefab, num6));
			}
			if (ValConfig.EnableDebugLootDetails.Value)
			{
				Logger.LogLoot($"Generated drops for {name}:\n{stringBuilder}");
			}
			return list;
		}

		private static void AppendOrLog(StringBuilder detail, string msg)
		{
			if (detail != null)
			{
				detail.AppendLine(msg);
			}
			else
			{
				Logger.LogLoot(msg);
			}
		}

		private static int MultiplyLootPerLevel(int lootDrop_amount, int level, DataObjects.DistanceLootModifier damageMod, float scale_factor = 1f, StringBuilder detail = null)
		{
			if (level == 1)
			{
				detail?.AppendLine($"  level 1: no per-level scaling, amount stays {lootDrop_amount}.");
				return lootDrop_amount;
			}
			float num = (float)level * ValConfig.PerLevelLootScale.Value * (scale_factor + damageMod.MinAmountScaleFactorBonus);
			float num2 = (float)level * ValConfig.PerLevelLootScale.Value * (scale_factor + damageMod.MaxAmountScaleFactorBonus);
			if (num == num2)
			{
				int num3 = Mathf.RoundToInt(num * (float)lootDrop_amount);
				AppendOrLog(detail, $"  MultiplyLootPerLevel {num3} = base {lootDrop_amount} * {num} scale from (lvl:{level} * PerLevelLootScale:{ValConfig.PerLevelLootScale.Value}) * (factor:{scale_factor} + scaleFactorBonus:{damageMod.MinAmountScaleFactorBonus})");
				return num3;
			}
			int num4 = Mathf.RoundToInt(num * (float)lootDrop_amount);
			int num5 = Mathf.RoundToInt(num2 * (float)lootDrop_amount);
			int num6 = Random.Range(num4, num5);
			AppendOrLog(detail, $"  MultiplyLootPerLevel {num6} picked from [{num4}..{num5}) = base {lootDrop_amount} * scale min:{num}/max:{num2} from (lvl:{level} * PerLevelLootScale:{ValConfig.PerLevelLootScale.Value}) * (factor:{scale_factor} + scaleFactorBonus min:{damageMod.MinAmountScaleFactorBonus}/max:{damageMod.MaxAmountScaleFactorBonus})");
			return num6;
		}

		private static int ExponentLootPerLevel(int lootDrop_amount, int level, DataObjects.DistanceLootModifier damageMod, float scale_factor = 1f, StringBuilder detail = null)
		{
			if (level == 1)
			{
				detail?.AppendLine($"  level 1: no per-level scaling, amount stays {lootDrop_amount}.");
				return lootDrop_amount;
			}
			float num = ValConfig.PerLevelLootScale.Value + damageMod.MinAmountScaleFactorBonus + scale_factor;
			float num2 = ValConfig.PerLevelLootScale.Value + damageMod.MaxAmountScaleFactorBonus + scale_factor;
			float num3 = Random.Range(num, num2);
			float num4 = Mathf.Pow(num3, (float)level);
			int num5 = Mathf.RoundToInt(num4 * (float)lootDrop_amount);
			AppendOrLog(detail, $"  ExponentLootPerLevel {num5} = base {lootDrop_amount} * ({num3}^lvl{level} = {num4}); mod picked from [{num}..{num2}) = (factor:{scale_factor} + distance min:{damageMod.MinAmountScaleFactorBonus}/max:{damageMod.MaxAmountScaleFactorBonus} + PerLevelLootScale:{ValConfig.PerLevelLootScale.Value})");
			return num5;
		}

		private static int ChancePerLevel(int lootDrop_amount, int level, DataObjects.DistanceLootModifier damageMod, float scale_factor = 1f, StringBuilder detail = null)
		{
			if (level <= 1)
			{
				detail?.AppendLine($"  level 1: no per-level chance scaling, amount stays {lootDrop_amount}.");
				return lootDrop_amount;
			}
			float num = ValConfig.PerLevelLootScale.Value + damageMod.MinAmountScaleFactorBonus + scale_factor;
			float num2 = ValConfig.PerLevelLootScale.Value + damageMod.MaxAmountScaleFactorBonus + scale_factor;
			float num3 = Random.Range(num, num2);
			float num4 = Mathf.Pow(num3, (float)level);
			float value = Random.value;
			bool flag = value < num4;
			AppendOrLog(detail, string.Format("  ChancePerLevel roll {0} vs chance {1} ({2}^lvl{3}) -> {4}; mod picked from [{5}..{6}) = (factor:{7} + distance min:{8}/max:{9} + PerLevelLootScale:{10})", value, num4, num3, level, flag ? $"win, amount {lootDrop_amount}" : "loss, amount 0", num, num2, scale_factor, damageMod.MinAmountScaleFactorBonus, damageMod.MaxAmountScaleFactorBonus, ValConfig.PerLevelLootScale.Value));
			if (!flag)
			{
				return 0;
			}
			return lootDrop_amount;
		}

		internal static DropTable UpdateDropTableByLevel(DropTable dropTable, int level, float mod)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (level > 1)
			{
				DropTable val = dropTable.Clone();
				List<DropData> list = new List<DropData>();
				foreach (DropData drop in dropTable.m_drops)
				{
					DropData val2 = drop;
					val2.m_stackMin = Mathf.RoundToInt((float)drop.m_stackMin * (1f + mod * (float)level));
					val2.m_stackMax = Mathf.RoundToInt((float)drop.m_stackMax * (1f + mod * (float)level));
					Logger.LogDebug($"Scaling drop {drop.m_item} from {drop.m_stackMin}-{drop.m_stackMax} to {val2.m_stackMin}-{val2.m_stackMax} for level {level}.");
					list.Add(val2);
				}
				val.m_drops = list;
				return val;
			}
			return dropTable;
		}

		internal static List<DataObjects.LootEntry> OptimizeToDropStacks(List<GameObject> drops, DataObjects.DropType dropType = DataObjects.DropType.None, float lootMultiplier = 1f)
		{
			List<DataObjects.LootEntry> list = new List<DataObjects.LootEntry>();
			Dictionary<GameObject, int> dictionary = new Dictionary<GameObject, int>();
			foreach (GameObject drop in drops)
			{
				if (dictionary.ContainsKey(drop))
				{
					dictionary[drop]++;
				}
				else
				{
					dictionary.Add(drop, 1);
				}
			}
			if (lootMultiplier != 1f)
			{
				foreach (KeyValuePair<GameObject, int> item in dictionary)
				{
					int maxAmountPerDrop = LootPerformanceChanges.CheckItemStackingConfig(item.Key.GetComponent<ItemDrop>(), dropType);
					int num = Mathf.RoundToInt((float)item.Value * lootMultiplier);
					Logger.LogDebug($"{item.Key} loot modified: {item.Value} * {lootMultiplier} = {num}");
					list.Add(new DataObjects.LootEntry
					{
						Prefab = item.Key,
						Amount = num,
						MaxAmountPerDrop = maxAmountPerDrop
					});
				}
			}
			else
			{
				foreach (KeyValuePair<GameObject, int> item2 in dictionary)
				{
					int maxAmountPerDrop2 = LootPerformanceChanges.CheckItemStackingConfig(item2.Key.GetComponent<ItemDrop>(), dropType);
					list.Add(new DataObjects.LootEntry
					{
						Prefab = item2.Key,
						Amount = item2.Value,
						MaxAmountPerDrop = maxAmountPerDrop2
					});
				}
			}
			return list;
		}

		public static void SelectCharacterLootSettings(Character creature, out DataObjects.DistanceLootModifier distance_bonus)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)creature).gameObject.transform.position;
			float distance_from_center = Vector2.Distance(new Vector2(position.x, position.z), new Vector2(DistanceScaleSystem.center.x, DistanceScaleSystem.center.z));
			distance_bonus = SelectDistanceFromCenterLootBonus(distance_from_center);
		}

		public static void SelectObjectDistanceBonus(Transform transform, out DataObjects.DistanceLootModifier distance_bonus)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = transform.position;
			float distance_from_center = Vector2.Distance(new Vector2(position.x, position.z), new Vector2(DistanceScaleSystem.center.x, DistanceScaleSystem.center.z));
			distance_bonus = SelectDistanceFromCenterLootBonus(distance_from_center);
		}

		private static DataObjects.DistanceLootModifier SelectDistanceFromCenterLootBonus(float distance_from_center)
		{
			DataObjects.DistanceLootModifier result = new DataObjects.DistanceLootModifier();
			if (LootSystemData.SLS_Drop_Settings != null && LootSystemData.SLS_Drop_Settings.EnableDistanceLootModifier && LootSystemData.SLS_Drop_Settings.DistanceLootModifier != null)
			{
				foreach (KeyValuePair<int, DataObjects.DistanceLootModifier> item in LootSystemData.SLS_Drop_Settings.DistanceLootModifier)
				{
					if (distance_from_center <= (float)item.Key)
					{
						result = item.Value;
						break;
					}
				}
			}
			return result;
		}
	}
}
namespace StarLevelSystem.modules.LevelSystem
{
	internal static class ConditionalScaleSystem
	{
		internal static Dictionary<Biome, SortedDictionary<int, float>> CurrentGlobalKeyConditionalLevelup = new Dictionary<Biome, SortedDictionary<int, float>>();

		private static readonly Dictionary<Biome, List<DataObjects.LevelGenerator>> resolvedByBiome = new Dictionary<Biome, List<DataObjects.LevelGenerator>>();

		private static string CurrentGlobalKey = null;

		private static bool cacheValid = false;

		internal static SortedDictionary<int, float> GetConditionalLevelupChance(Biome biome)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			DataObjects.CreatureLevelSettings sLE_Level_Settings = LevelSystemData.SLE_Level_Settings;
			if (sLE_Level_Settings == null || !sLE_Level_Settings.EnableConditionalCreatureLevelupChance || sLE_Level_Settings.ConditionalCreatureLevelupChance == null)
			{
				return null;
			}
			if (!cacheValid)
			{
				RebuildCache();
			}
			if (CurrentGlobalKeyConditionalLevelup.TryGetValue(biome, out var value))
			{
				return value;
			}
			return null;
		}

		private static void RebuildCache()
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			CurrentGlobalKey = null;
			CurrentGlobalKeyConditionalLevelup.Clear();
			resolvedByBiome.Clear();
			Dictionary<string, Dictionary<Biome, DataObjects.ConditionalLevelupChance>> dictionary = LevelSystemData.SLE_Level_Settings?.ConditionalCreatureLevelupChance;
			if (dictionary == null || (Object)(object)ZoneSystem.instance == (Object)null)
			{
				cacheValid = true;
				return;
			}
			foreach (KeyValuePair<string, Dictionary<Biome, DataObjects.ConditionalLevelupChance>> item in dictionary)
			{
				if (item.Key != null && ZoneSystem.instance.GetGlobalKey(item.Key))
				{
					CurrentGlobalKey = item.Key;
					break;
				}
			}
			if (CurrentGlobalKey == null || !dictionary.TryGetValue(CurrentGlobalKey, out var value) || value == null)
			{
				cacheValid = true;
				return;
			}
			foreach (KeyValuePair<Biome, DataObjects.ConditionalLevelupChance> item2 in value)
			{
				if (item2.Value == null)
				{
					continue;
				}
				List<DataObjects.LevelGenerator> list = LevelGeneratorResolver.Resolve(item2.Value.LevelupGenerators, item2.Value.LevelupGeneratorRefs);
				if (list.Count == 0)
				{
					continue;
				}
				resolvedByBiome[item2.Key] = list;
				SortedDictionary<int, float> sortedDictionary = new SortedDictionary<int, float>();
				foreach (DataObjects.LevelGenerator item3 in list)
				{
					sortedDictionary.MergeSortedDictionary(item3.GetLevelUpDefinition());
				}
				CurrentGlobalKeyConditionalLevelup[item2.Key] = sortedDictionary;
			}
			Logger.LogDebug($"BossScaleSystem: resolved conditional levelup generators for '{CurrentGlobalKey}' across {resolvedByBiome.Count} biome(s).");
			cacheValid = true;
		}

		internal static void ResetCache()
		{
			cacheValid = false;
			CurrentGlobalKey = null;
			resolvedByBiome.Clear();
		}
	}
	internal static class DistanceScaleSystem
	{
		public static Vector3 center = new Vector3(0f, 0f, 0f);

		private static bool buildingMapRings = false;

		private static bool ringAvailable = false;

		public static void DelayedMinimapSetup()
		{
			if (MinimapOverlayFog.CanDrawOverlays())
			{
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(CheckAndDrawMapRings());
			}
		}

		private static IEnumerator CheckAndDrawMapRings()
		{
			if (ZNet.instance.IsCurrentServerDedicated())
			{
				int iterations = 0;
				while (!ValConfig.ServerConfigsSynced)
				{
					Logger.LogDebug("Waiting for config sync to complete before drawing map rings on dedicated server.");
					yield return (object)new WaitForSeconds(5f);
					iterations++;
					if (iterations >= 25)
					{
						Logger.LogWarning("Config sync not detected. Waiting timeframe expired.");
						break;
					}
				}
			}
			CreateLevelBonusRingMapOverlays();
		}

		internal static SortedDictionary<int, float> SelectDistanceFromCenterLevelBonus(float distance_from_center)
		{
			SortedDictionary<int, float> sortedDictionary = new SortedDictionary<int, float>();
			if (ValConfig.EnableDistanceLevelScalingBonus.Value && LevelSystemData.SLE_Level_Settings.DistanceLevelBonus != null)
			{
				foreach (KeyValuePair<int, SortedDictionary<int, float>> distanceLevelBonu in LevelSystemData.SLE_Level_Settings.DistanceLevelBonus)
				{
					if (distance_from_center >= (float)distanceLevelBonu.Key)
					{
						sortedDictionary = distanceLevelBonu.Value;
					}
					if (distance_from_center < (float)distanceLevelBonu.Key)
					{
						return sortedDictionary;
					}
				}
				if (sortedDictionary.Count > 0)
				{
					return sortedDictionary;
				}
			}
			return new SortedDictionary<int, float>();
		}

		internal static int GetCurrentRingLevel(Vector3 pos)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (LevelSystemData.SLE_Level_Settings?.DistanceLevelBonus == null)
			{
				return 0;
			}
			float num = Vector2.Distance(new Vector2(pos.x, pos.z), new Vector2(center.x, center.z));
			int num2 = 0;
			foreach (int key in LevelSystemData.SLE_Level_Settings.DistanceLevelBonus.Keys)
			{
				if (num >= (float)key)
				{
					num2++;
					continue;
				}
				break;
			}
			return num2;
		}

		private static void CreateLevelBonusRingMapOverlays()
		{
			if (ValConfig.EnableMapRingsForDistanceBonus.Value)
			{
				SetRingCenter();
				Logger.LogDebug("Creating Level Bonus Rings on Map");
				if (!buildingMapRings)
				{
					buildingMapRings = true;
					((MonoBehaviour)TaskRunner.Run()).StartCoroutine(BuildMapRingOverlay());
				}
			}
		}

		public static void OnRingCenterChanged(object s, EventArgs e)
		{
			if (MinimapOverlayFog.CanDrawOverlays() && !ZNet.instance.IsCurrentServerDedicated())
			{
				SetRingCenter();
				DelayedMinimapSetup();
			}
		}

		public static void SetRingCenter()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (ValConfig.DistanceBonusIsFromStarterTemple.Value)
			{
				GameObject val = (from obj in Resources.FindObjectsOfTypeAll<GameObject>()
					where ((Object)obj).name == "StartTemple"
					select obj).FirstOrDefault();
				if ((Object)(object)val != (Object)null)
				{
					center = val.transform.position;
					return;
				}
				Logger.LogWarning("Unable to find starter temple, bonus rings will use world center. (0,0,0)");
				center = new Vector3(0f, 0f, 0f);
			}
			else
			{
				center = new Vector3(0f, 0f, 0f);
			}
		}

		public static void UpdateMapColorSettingsOnChange(object s, EventArgs e)
		{
			Colorization.UpdateMapColorSelection();
			DelayedMinimapSetup();
		}

		public static void UpdateMapRingFogSettingOnChange(object s, EventArgs e)
		{
			if (ValConfig.EnableMapRingsForDistanceBonus.Value)
			{
				DelayedMinimapSetup();
			}
		}

		public static void UpdateMapRingEnableSettingOnChange(object s, EventArgs e)
		{
			if (ValConfig.EnableMapRingsForDistanceBonus.Value)
			{
				DelayedMinimapSetup();
			}
			else if (ringAvailable && MinimapOverlayFog.CanDrawOverlays())
			{
				MapOverlay mapOverlay = MinimapManager.Instance.GetMapOverlay("SLS-LevelBonus", true);
				if (mapOverlay != null)
				{
					mapOverlay.Enabled = false;
				}
			}
		}

		private static IEnumerator BuildMapRingOverlay()
		{
			try
			{
				if (LevelSystemData.SLE_Level_Settings.DistanceLevelBonus == null || LevelSystemData.SLE_Level_Settings.DistanceLevelBonus.Keys.Count <= 0)
				{
					yield break;
				}
				if (ZNet.instance.IsDedicated())
				{
					Logger.LogDebug("Server is headless, skipping minimap generation");
					yield break;
				}
				MapOverlay ringbonuses = MinimapManager.Instance.GetMapOverlay("SLS-LevelBonus", true);
				if (ringbonuses == null)
				{
					yield break;
				}
				ringbonuses.Enabled = true;
				bool aboveFog = ValConfig.MapRingsAboveFog.Value;
				int num = ((MapOverlayBase)ringbonuses).TextureSize * ((MapOverlayBase)ringbonuses).TextureSize;
				Color[] mainPixels = (Color[])(object)new Color[num];
				ringbonuses.OverlayTex.SetPixels(mainPixels);
				int world_x = default(int);
				int world_y = default(int);
				Minimap.instance.WorldToPixel(center, ref world_x, ref world_y);
				Logger.LogDebug($"Map centered: x:{world_x} y:{world_y}");
				if (LevelSystemData.SLE_Level_Settings == null || LevelSystemData.SLE_Level_Settings.DistanceLevelBonus == null || Colorization.mapRingColors == null || Colorization.mapRingColors.Count == 0)
				{
					yield break;
				}
				int updates = 0;
				int levelring_color_index = 0;
				Vector3 val = default(Vector3);
				int num2 = default(int);
				int num3 = default(int);
				foreach (int key in LevelSystemData.SLE_Level_Settings.DistanceLevelBonus.Keys)
				{
					if (levelring_color_index >= Colorization.mapRingColors.Count)
					{
						levelring_color_index = 0;
					}
					Color selectedColor = Colorization.mapRingColors[levelring_color_index];
					levelring_color_index++;
					int granularity = key * 10;
					((Vector3)(ref val))..ctor(center.x + (float)key, center.y, center.z);
					Minimap.instance.WorldToPixel(val, ref num2, ref num3);
					int map_radii = num2 - world_x;
					Logger.LogDebug($"Set Ringsize: {key} -PixelMap-> {num2} | {map_radii}");
					float delta = (float)Math.PI * 2f / (float)granularity;
					for (int i = 0; i < granularity; i++)
					{
						updates++;
						if (updates % 3000 == 0)
						{
							yield return (object)new WaitForEndOfFrame();
						}
						float num4 = delta * (float)i;
						int num5 = Mathf.RoundToInt((float)world_x + Mathf.Cos(num4) * (float)map_radii);
						int num6 = Mathf.RoundToInt((float)world_y + Mathf.Sin(num4) * (float)map_radii);
						if (ringbonuses != null)
						{
							int num7 = num6 * ((MapOverlayBase)ringbonuses).TextureSize + num5;
							if (num7 < mainPixels.Length && num7 >= 0 && (aboveFog || MinimapOverlayFog.IsPixelExplored(num5, num6)))
							{
								mainPixels[num7] = selectedColor;
							}
							continue;
						}
						yield break;
					}
				}
				if (ringbonuses != null)
				{
					ringbonuses.OverlayTex.SetPixels(mainPixels);
					ringbonuses.OverlayTex.Apply();
					Logger.LogDebug("Finished Creating Level Bonus Rings on Minimap");
					ringAvailable = true;
				}
			}
			finally
			{
				buildingMapRings = false;
			}
		}
	}
	internal static class LevelGeneratorResolver
	{
		internal static List<DataObjects.LevelGenerator> Resolve(List<DataObjects.LevelGenerator> inline, List<string> refs)
		{
			List<DataObjects.LevelGenerator> list = new List<DataObjects.LevelGenerator>();
			if (inline != null)
			{
				list.AddRange(inline);
			}
			if (refs != null && refs.Count > 0)
			{
				Dictionary<string, List<DataObjects.LevelGenerator>> dictionary = LevelSystemData.SLE_Level_Settings?.CustomLevelupGenerators;
				foreach (string @ref in refs)
				{
					if (@ref != null)
					{
						if (dictionary != null && dictionary.TryGetValue(@ref, out var value) && value != null)
						{
							list.AddRange(value);
						}
						else
						{
							Logger.LogWarning("Levelup generator reference '" + @ref + "' was not found in CreatureLevelSettings.CustomLevelupGenerators.");
						}
					}
				}
			}
			return list;
		}

		internal static bool HasGenerators(List<DataObjects.LevelGenerator> inline, List<string> refs)
		{
			if (inline == null || inline.Count <= 0)
			{
				if (refs != null)
				{
					return refs.Count > 0;
				}
				return false;
			}
			return true;
		}

		internal static SortedDictionary<int, float> BuildLevelupChance(List<DataObjects.LevelGenerator> inline, List<string> refs)
		{
			if (!HasGenerators(inline, refs))
			{
				return null;
			}
			List<DataObjects.LevelGenerator> list = Resolve(inline, refs);
			if (list.Count == 0)
			{
				return null;
			}
			SortedDictionary<int, float> sortedDictionary = new SortedDictionary<int, float>();
			foreach (DataObjects.LevelGenerator item in list)
			{
				sortedDictionary.MergeSortedDictionary(item.GetLevelUpDefinition());
			}
			return sortedDictionary;
		}

		internal static int RollLevel(List<DataObjects.LevelGenerator> inline, List<string> refs)
		{
			if (!HasGenerators(inline, refs))
			{
				return 0;
			}
			List<DataObjects.LevelGenerator> list = Resolve(inline, refs);
			if (list.Count == 0)
			{
				return 0;
			}
			SortedDictionary<int, float> sortedDictionary = new SortedDictionary<int, float>();
			int num = 1;
			foreach (DataObjects.LevelGenerator item in list)
			{
				sortedDictionary.MergeSortedDictionary(item.GetLevelUpDefinition());
				if (item.MaxLevel > num)
				{
					num = item.MaxLevel;
				}
			}
			return LevelSelection.DetermineLevelRollResult(Random.Range(0f, 100f), num, sortedDictionary, new SortedDictionary<int, float>(), 1f);
		}
	}
	internal static class LevelPatches
	{
		[HarmonyPatch(typeof(TreeBase), "Awake")]
		public static class RandomTreeLevelExtension
		{
			public static void Postfix(TreeBase __instance)
			{
				if (!ValConfig.EnableTreeScaling.Value)
				{
					return;
				}
				int num = 0;
				if (ValConfig.UseDeterministicTreeScaling.Value)
				{
					num = CompositeLazyCache.GetOrAddCachedTreeEntry(__instance.m_nview);
				}
				else
				{
					num = __instance.m_nview.GetZDO().GetInt(DataObjects.SLS_TREE, 0);
					if (num == 0)
					{
						LevelSelection.SelectCreatureBiomeSettings(((Component)__instance).gameObject, out var creature_name, out var creature_settings, out var biome_settings, out var _);
						num = LevelSelection.DetermineLevel(((Component)__instance).gameObject, creature_name, creature_settings, biome_settings, ValConfig.TreeMaxLevel.Value);
						__instance.m_nview.GetZDO().Set(DataObjects.SLS_TREE, num);
					}
				}
				if (num >= 1)
				{
					((MonoBehaviour)__instance).StartCoroutine(LevelSelection.ModifyTreeWithLevel(__instance, num));
				}
			}
		}

		[HarmonyPatch(typeof(TreeLog))]
		public static class SetTreeLogPassLevel
		{
			[HarmonyPatch("Destroy")]
			[HarmonyPrefix]
			private static bool DropAndSpawnTreeLogs(TreeLog __instance)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				List<DataObjects.LootEntry> optimizeDrops = LootStyles.ModifyTreeDropsOrDefault(__instance);
				Vector3 val = ((Component)__instance).transform.position + ((Component)__instance).transform.up * Random.Range(0f - __instance.m_spawnDistance, __instance.m_spawnDistance) + Vector3.up * 0.3f;
				__instance.m_destroyedEffect.Create(val, ((Component)__instance).transform.rotation, (Transform)null, 1f, -1);
				LootPerformanceChanges.DropItemsPreferAsync(val, optimizeDrops);
				if ((Object)(object)__instance.m_subLogPrefab != (Object)null)
				{
					Transform[] subLogPoints = __instance.m_subLogPoints;
					foreach (Transform val2 in subLogPoints)
					{
						Quaternion val3 = (__instance.m_useSubLogPointRotation ? ((Component)__instance).transform.rotation : ((Component)__instance).transform.rotation);
						Logger.LogDebug($"Spawning Treelog at point {val2.position} rot:{val3}");
						SetupTreeLog(__instance, val2, val3);
					}
				}
				if (ValConfig.EnableTreeScaling.Value && (Object)(object)__instance.m_nview != (Object)null && __instance.m_nview.GetZDO() != null)
				{
					CompositeLazyCache.RemoveTreeCacheEntry(__instance.m_nview.GetZDO().m_uid);
				}
				ZNetScene.instance.Destroy(((Component)__instance).gameObject);
				return false;
			}

			[HarmonyPatch("Awake")]
			[HarmonyPostfix]
			private static void SetupAwakeLog(TreeLog __instance)
			{
				if (ValConfig.EnableTreeScaling.Value)
				{
					int num = 1;
					if (ValConfig.UseDeterministicTreeScaling.Value)
					{
						num = CompositeLazyCache.GetOrAddCachedTreeEntry(__instance.m_nview);
					}
					else if (__instance.m_nview.GetZDO() != null)
					{
						num = __instance.m_nview.GetZDO().GetInt(DataObjects.SLS_TREE, 1);
					}
					__instance.m_health += __instance.m_health * 0.1f * (float)num;
					ImpactEffect component = ((Component)__instance).GetComponent<ImpactEffect>();
					if (component != null)
					{
						((DamageTypes)(ref component.m_damages)).Modify(1f + 0.1f * (float)num);
					}
				}
			}

			internal static void SetupTreeLog(TreeLog instance, Transform tform, Quaternion qt)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				GameObject obj = Object.Instantiate<GameObject>(instance.m_subLogPrefab, tform.position, qt);
				ZNetView component = obj.GetComponent<ZNetView>();
				TreeLog component2 = obj.GetComponent<TreeLog>();
				component.SetLocalScale(((Component)instance).transform.localScale);
				int num = 1;
				if (ValConfig.EnableTreeScaling.Value)
				{
					if (ValConfig.UseDeterministicTreeScaling.Value)
					{
						num = CompositeLazyCache.GetOrAddCachedTreeEntry(instance.m_nview);
					}
					else if (instance.m_nview.GetZDO() != null)
					{
						num = instance.m_nview.GetZDO().GetInt(DataObjects.SLS_TREE, 1);
					}
				}
				component2.m_health += component2.m_health * 0.1f * (float)num;
				ImpactEffect component3 = obj.GetComponent<ImpactEffect>();
				if (component3 != null)
				{
					((DamageTypes)(ref component3.m_damages)).Modify(1f + 0.1f * (float)num);
				}
				if (!ValConfig.UseDeterministicTreeScaling.Value)
				{
					component.GetZDO().Set(DataObjects.SLS_TREE, num);
				}
			}
		}

		[HarmonyPatch(typeof(RandomFlyingBird), "Awake")]
		public static class RandomFlyingBirdExtension
		{
			public static void Postfix(RandomFlyingBird __instance)
			{
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				if (!ValConfig.EnableScalingBirds.Value)
				{
					return;
				}
				int num = __instance.m_nview.GetZDO().GetInt(DataObjects.SLS_BIRD, 0);
				if (num == 0)
				{
					LevelSelection.SelectCreatureBiomeSettings(((Component)__instance).gameObject, out var creature_name, out var creature_settings, out var biome_settings, out var _);
					num = LevelSelection.DetermineLevel(((Component)__instance).gameObject, creature_name, creature_settings, biome_settings, ValConfig.BirdMaxLevel.Value);
					__instance.m_nview.GetZDO().Set(DataObjects.SLS_BIRD, num);
				}
				if (num <= 1)
				{
					return;
				}
				float num2 = 1f + ValConfig.BirdSizeScalePerLevel.Value * (float)num;
				Transform transform = ((Component)__instance).transform;
				transform.localScale *= num2;
				Physics.SyncTransforms();
				DropOnDestroyed component = ((Component)__instance).gameObject.GetComponent<DropOnDestroyed>();
				List<DropData> list = new List<DropData>();
				foreach (DropData drop in component.m_dropWhenDestroyed.m_drops)
				{
					list.Add(new DropData
					{
						m_stackMin = Mathf.RoundToInt((float)drop.m_stackMin * (1f + ValConfig.PerLevelBirdLootScale.Value * (float)num)),
						m_stackMax = Mathf.RoundToInt((float)drop.m_stackMax * (1f + ValConfig.PerLevelBirdLootScale.Value * (float)num)),
						m_item = drop.m_item
					});
				}
				component.m_dropWhenDestroyed.m_drops = list;
			}
		}

		[HarmonyPatch(typeof(Growup))]
		public static class SetGrowUpLevel
		{
			[HarmonyTranspiler]
			[HarmonyPatch("GrowUpdate")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Character), "GetLevel", (Type[])null, (Type[])null), (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Character), "SetLevel", (Type[])null, (Type[])null), (string)null)
				}).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<Character, Character>>((Action<Character, Character>)SetupGrownUp) })
					.ThrowIfNotMatch("Unable to patch child grow up level set.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			internal static void SetupGrownUp(Character grownup, Character childChar)
			{
				DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(childChar);
				int leveloverride = 0;
				if (cacheEntry == null)
				{
					leveloverride = childChar.m_level;
					grownup.SetLevel(childChar.m_level);
				}
				DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(grownup);
				andSetLocalCache.CreatureModifiers = cacheEntry.CreatureModifiers;
				andSetLocalCache.Level = cacheEntry.Level;
				CompositeLazyCache.SetCreatureModifiers(grownup, cacheEntry.CreatureModifiers);
				CreatureSetupControl.CreatureSpawnerSetup(grownup, leveloverride, multiply: false);
			}
		}

		[HarmonyPatch]
		public static class SetChildLevel
		{
			[HarmonyTranspiler]
			[HarmonyPatch(typeof(Procreation), "Procreate")]
			private static IEnumerable<CodeInstruction> SetChildLevelProcreateTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Expected O, but got Unknown
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Expected O, but got Unknown
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Expected O, but got Unknown
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Expected O, but got Unknown
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Expected O, but got Unknown
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Tameable), "IsTamed", (Type[])null, (Type[])null), (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Character), "SetTamed", (Type[])null, (Type[])null), (string)null)
				}).RemoveInstructions(15).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldloc, (object)(byte)6),
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					Transpilers.EmitDelegate<Action<Character, Procreation>>((Action<Character, Procreation>)SetupChildCharacter)
				})
					.MatchStartForward((CodeMatch[])(object)new CodeMatch[5]
					{
						new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(Procreation), "m_minOffspringLevel"), (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(Procreation), "m_character"), (string)null)
					})
					.Advance(2)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<ItemDrop, Procreation>>((Action<ItemDrop, Procreation>)SetupEggItem) })
					.RemoveInstructions(13)
					.ThrowIfNotMatch("Unable to patch child spawn level set.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			[HarmonyTranspiler]
			[HarmonyPatch(typeof(EggGrow), "GrowUpdate")]
			private static IEnumerable<CodeInstruction> EggSetChildLevelTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Expected O, but got Unknown
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, generator);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[5]
				{
					new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(EggGrow), "m_item"), (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ItemData), "m_quality"), (string)null)
				}).Advance(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<Character, EggGrow>>((Action<Character, EggGrow>)ControlEggSpawnLevelInheritance) })
					.RemoveInstructions(4)
					.ThrowIfNotMatch("Unable to patch Egg.GrowUpdate", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			private static void ControlEggSpawnLevelInheritance(Character spawnedChar, EggGrow egg)
			{
				if (ValConfig.EggLevelDeterminedByItemQuality.Value)
				{
					int quality = egg.m_item.m_itemData.m_quality;
					Logger.LogDebug($"Setting egg spawn level based on item quality {quality}.");
					CreatureSetupControl.CreatureSetup(spawnedChar, quality);
				}
				else
				{
					CreatureSetupControl.CreatureSetup(spawnedChar);
				}
				CheckToMakeOffspringInfertile(spawnedChar);
			}

			private static void CheckToMakeOffspringInfertile(Character chara)
			{
				if (ValConfig.OffspringCanBeInfertile.Value && Random.value <= ValConfig.OffspringChanceToBeInfertile.Value)
				{
					chara.m_nview.GetZDO().Set(DataObjects.SLS_INFERTILE, true);
					Logger.LogDebug("Child is infertile.");
				}
			}

			internal static void SetupEggItem(ItemDrop item, Procreation proclass)
			{
				if (ValConfig.LootEggsDropIncreaseStacks.Value)
				{
					int num = Mathf.RoundToInt(1f * (1f + ValConfig.PerLevelLootScale.Value * (float)proclass.m_character.m_level));
					if (num > item.m_itemData.m_shared.m_maxStackSize)
					{
						num = item.m_itemData.m_shared.m_maxStackSize;
					}
					item.m_itemData.m_stack = num;
					item.SetQuality(1);
				}
				else
				{
					int num2 = Mathf.Max(proclass.m_minOffspringLevel, Object.op_Implicit((Object)(object)proclass.m_character) ? proclass.m_character.GetLevel() : proclass.m_minOffspringLevel);
					if (ValConfig.OffspringCanBeStrongerThanParents.Value && Random.value <= ValConfig.OffspringGainExtraLevelChance.Value)
					{
						num2++;
						Logger.LogDebug("Child egg is stronger than parents and has a higher max level.");
					}
					item.SetQuality(num2);
				}
			}

			internal static void SetupChildCharacter(Character chara, Procreation proc)
			{
				Logger.LogDebug("Setting child level for " + chara.m_name);
				chara.SetTamed(true);
				DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(proc.m_character);
				if (!ValConfig.RandomizeTameChildrenModifiers.Value && (Object)(object)proc.m_character != (Object)null && cacheEntry != null)
				{
					CompositeLazyCache.SetCreatureModifiers(chara, cacheEntry.CreatureModifiers);
				}
				if (!ValConfig.SpawnMultiplicationAppliesToTames.Value && chara.m_nview.GetZDO() != null)
				{
					Logger.LogDebug("Disabling spawn multiplier for tamed child.");
					chara.m_nview.GetZDO().Set(DataObjects.SLS_SPAWN_MULT, true);
				}
				int num = proc.m_character.m_level;
				if (cacheEntry != null && cacheEntry.Level != 0)
				{
					num = cacheEntry.Level;
				}
				if (ValConfig.RandomizeTameChildrenLevels.Value)
				{
					int num2 = Random.Range(1, num);
					if (ValConfig.OffspringCanBeStrongerThanParents.Value && Random.value <= ValConfig.OffspringGainExtraLevelChance.Value)
					{
						num2++;
						Logger.LogDebug("Child is strong, but still random.");
					}
					Logger.LogDebug($"Character randomized level {num2} (1-{num}) being used for child.");
					CompositeLazyCache.GetAndSetLocalCache(chara, num, null, null, updateCache: true);
					chara.m_nview.GetZDO().Set(ZDOVars.s_level, num, false);
					CreatureSetupControl.CreatureSetup(chara, num2, multiply: true, 0.1f);
				}
				else
				{
					if (ValConfig.OffspringCanBeStrongerThanParents.Value && Random.value <= ValConfig.OffspringGainExtraLevelChance.Value)
					{
						num++;
						Logger.LogDebug("Child is stronger than parents and has a higher max level.");
					}
					Logger.LogDebug($"Parent level {num} being used for child from: proc-{proc.m_character.m_level} cdc-{cacheEntry.Level}.");
					CompositeLazyCache.GetAndSetLocalCache(chara, num, null, null, updateCache: true);
					chara.m_nview.GetZDO().Set(ZDOVars.s_level, num, false);
					CreatureSetupControl.CreatureSetup(chara, num, multiply: true, 0.1f);
				}
				CheckToMakeOffspringInfertile(chara);
			}
		}

		[HarmonyPatch(typeof(Procreation), "ReadyForProcreation")]
		public static class ProcreationPrevention
		{
			public static void Postfix(Procreation __instance, ref bool __result)
			{
				if (((Object)(object)__instance.m_character != (Object)null || (Object)(object)__instance.m_character.m_nview != (Object)null || (__instance.m_character.m_nview.GetZDO() != null && __result)) && __instance.m_nview.GetZDO().GetBool(DataObjects.SLS_INFERTILE, false))
				{
					__result = false;
					Logger.LogDebug("Preventing procreation because child is infertile.");
				}
			}
		}

		[HarmonyPatch(typeof(Tameable), "GetHoverText")]
		public static class ProcreationPreventionDisplay
		{
			public static void Postfix(Tameable __instance, ref string __result)
			{
				if ((Object)(object)__instance.m_character != (Object)null && (Object)(object)__instance.m_character.m_nview != (Object)null && __instance.m_character.m_nview.GetZDO() != null && __instance.m_nview.GetZDO().GetBool(DataObjects.SLS_INFERTILE, false))
				{
					__result += Localization.instance.Localize("\n<color=red>$SLS_infertile</color>");
				}
			}
		}

		[HarmonyPatch(typeof(CreatureSpawner))]
		public static class CreatureSpawnerSpawn
		{
			[HarmonyTranspiler]
			[HarmonyPatch("Spawn")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Expected O, but got Unknown
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Expected O, but got Unknown
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Expected O, but got Unknown
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Expected O, but got Unknown
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Expected O, but got Unknown
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Expected O, but got Unknown
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, generator);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Character), "SetLevel", (Type[])null, (Type[])null), (string)null)
				}).RemoveInstructions(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<Character, int>>((Action<Character, int>)CreatureSpawnerCharacterLevelControl) })
					.MatchStartBackwards((CodeMatch[])(object)new CodeMatch[2]
					{
						new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null)
					})
					.Advance(1)
					.RemoveInstructions(1)
					.Insert((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldc_I4, (object)0)
					})
					.MatchStartBackwards((CodeMatch[])(object)new CodeMatch[3]
					{
						new CodeMatch((OpCode?)OpCodes.Stloc_S, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
						new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null)
					})
					.Advance(2)
					.RemoveInstructions(1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldc_I4, (object)0)
					})
					.ThrowIfNotMatch("Unable to patch CreatureSpawner.Spawn.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			private static void CreatureSpawnerCharacterLevelControl(Character chara, int providedLevel)
			{
				LevelSelection.SetCharacterLevelControl(chara, providedLevel);
			}

			[HarmonyPatch("Awake")]
			[HarmonyPostfix]
			public static void Postfix(CreatureSpawner __instance)
			{
				__instance.m_minLevel = 1;
			}
		}

		[HarmonyPatch(typeof(SpawnArea))]
		public static class SpawnAreaSpawnOnePatch
		{
			private static readonly List<string> VanillaSpawnAreaControllers = new List<string> { "EvilHeart_Forest", "Spawner_GreydwarfNest", "Spawner_DraugrPile", "BonePileSpawner", "Spawner_CharredCross", "Spawner_CharredStone_Elite", "Spawner_Kvastur", "Spawner_CharredStone", "Spawner_CharredStone_event", "EvilHeart_Swamp" };

			[HarmonyTranspiler]
			[HarmonyPatch("SpawnOne")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Expected O, but got Unknown
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, generator);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(GameObject), "GetComponent", (Type[])null, new Type[1] { typeof(Character) }), (string)null),
					new CodeMatch((OpCode?)OpCodes.Stloc_S, (object)null, (string)null)
				}).Advance(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
				{
					new CodeInstruction(OpCodes.Ldloc_S, (object)5),
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldloc_2, (object)null),
					Transpilers.EmitDelegate<Action<Character, SpawnArea, SpawnData>>((Action<Character, SpawnArea, SpawnData>)SpawnAreaSetCharacterLevelControl)
				})
					.CreateLabelOffset(out var label, 28)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Br, (object)label)
					})
					.ThrowIfNotMatch("Unable to patch SpawnArea.SpawnOne.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			private static void SpawnAreaSetCharacterLevelControl(Character chara, SpawnArea spawnArea, SpawnData spawndata)
			{
				if (ValConfig.ControlSpawnerLevels.Value)
				{
					if (ValConfig.OnlyControlVanillaAreaSpawners.Value)
					{
						VanillaSpawnAreaControllers.Contains(Utils.GetPrefabName(((Component)spawnArea).gameObject));
						CreatureSetupControl.CreatureSpawnerSetup(chara);
					}
					else
					{
						CreatureSetupControl.CreatureSpawnerSetup(chara);
					}
				}
				else
				{
					int num = new DataObjects.LevelGenerator
					{
						LevelUpChance = spawnArea.GetLevelUpChance(),
						MaxLevel = spawndata.m_maxLevel,
						MinLevel = spawndata.m_minLevel,
						PrefabName = ((Object)spawndata.m_prefab).name
					}.RollAndDetermineLevel();
					Logger.LogDebug($"SpawnArea.SpawnOne using provided {chara.m_name} level {num}");
					CreatureSetupControl.CreatureSpawnerSetup(chara, num);
				}
			}

			[HarmonyPatch("SelectWeightedPrefab")]
			[HarmonyPostfix]
			public static void Prefix(ref SpawnData __result)
			{
				if (__result != null)
				{
					__result.m_minLevel = 1;
				}
			}
		}

		[HarmonyPatch(typeof(SpawnSystem))]
		public static class SpawnSystemSpawnPatch
		{
			[HarmonyTranspiler]
			[HarmonyPatch("Spawn")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Expected O, but got Unknown
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Expected O, but got Unknown
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Expected O, but got Unknown
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Expected O, but got Unknown
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Expected O, but got Unknown
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, generator);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[5]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpawnData), "m_prefab"), (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_2, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Stloc_0, (object)null, (string)null)
				}).Advance(5).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					Transpilers.EmitDelegate<Action<GameObject>>((Action<GameObject>)SpawnSystemSetCharacterWithoutZoneLimits)
				})
					.MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
					{
						new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Character), "SetLevel", (Type[])null, (Type[])null), (string)null)
					})
					.RemoveInstructions(1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<Character, int>>((Action<Character, int>)SpawnSystemSetCharacterLevelControl) })
					.MatchStartBackwards((CodeMatch[])(object)new CodeMatch[2]
					{
						CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Ldloc_S, (object)null)),
						new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null)
					})
					.Advance(1)
					.RemoveInstructions(1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldc_I4, (object)0)
					})
					.MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
					{
						new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(ItemDrop), "SetQuality", (Type[])null, (Type[])null), (string)null)
					})
					.RemoveInstructions(1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<ItemDrop, int>>((Action<ItemDrop, int>)SetItemLevelFish) })
					.ThrowIfNotMatch("Unable to patch SpawnSystem Spawn set level.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			private static void SpawnSystemSetCharacterWithoutZoneLimits(GameObject go)
			{
				Character component = go.GetComponent<Character>();
				if (!((Object)(object)component == (Object)null))
				{
					LevelSelection.SetCharacterLevelControl(component, 1);
				}
			}

			private static void SetItemLevelFish(ItemDrop item, int _providedLevel)
			{
				LevelSelection.SelectCreatureBiomeSettings(((Component)item).gameObject, out var creature_name, out var creature_settings, out var biome_settings, out var _);
				int quality = LevelSelection.DetermineLevel(((Component)item).gameObject, creature_name, creature_settings, biome_settings, ValConfig.FishMaxLevel.Value);
				item.m_itemData.m_shared.m_maxQuality = ValConfig.FishMaxLevel.Value + 1;
				item.SetQuality(quality);
				item.m_itemData.m_shared.m_scaleByQuality = ValConfig.FishSizeScalePerLevel.Value;
				item.Save();
			}

			private static void SpawnSystemSetCharacterLevelControl(Character chara, int providedLevel)
			{
				LevelSelection.SetCharacterLevelControl(chara, providedLevel);
			}

			[HarmonyPatch("Spawn")]
			[HarmonyPrefix]
			public static void Prefix(ref SpawnData critter)
			{
				critter.m_minLevel = 1;
			}
		}

		[HarmonyPatch(typeof(TriggerSpawner))]
		public static class TriggerSpawnerSpawnPatch
		{
			[HarmonyTranspiler]
			[HarmonyPatch("Spawn")]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Expected O, but got Unknown
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Expected O, but got Unknown
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Expected O, but got Unknown
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Expected O, but got Unknown
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Expected O, but got Unknown
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Expected O, but got Unknown
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, generator);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Character), "SetLevel", (Type[])null, (Type[])null), (string)null)
				}).RemoveInstructions(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<Character, int>>((Action<Character, int>)TriggerSpawnerSetCharacterLevelControl) })
					.MatchStartBackwards((CodeMatch[])(object)new CodeMatch[2]
					{
						CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Ldloc_S, (object)null)),
						new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null)
					})
					.Advance(1)
					.RemoveInstructions(1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldc_I4, (object)0)
					})
					.MatchStartBackwards((CodeMatch[])(object)new CodeMatch[3]
					{
						CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Ldarg_0, (object)null)),
						CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(TriggerSpawner), "m_maxLevel"))),
						new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null)
					})
					.Advance(2)
					.RemoveInstructions(1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldc_I4, (object)0)
					})
					.ThrowIfNotMatch("Unable to patch TriggerSpawner.Spawn.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			private static void TriggerSpawnerSetCharacterLevelControl(Character chara, int providedLevel)
			{
				LevelSelection.SetCharacterLevelControl(chara, providedLevel);
			}

			[HarmonyPatch("Awake")]
			[HarmonyPostfix]
			public static void Postfix(TriggerSpawner __instance)
			{
				__instance.m_minLevel = 1;
			}
		}

		[HarmonyPatch(typeof(SpawnAbility))]
		public static class SpawnAbilitySpawnPatch
		{
			[HarmonyTranspiler]
			[HarmonyPatch(/*Could not decode attribute arguments.*/)]
			private static IEnumerable<CodeInstruction> TranspileMoveNext(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Character), "SetLevel", (Type[])null, (Type[])null), (string)null)
				}).RemoveInstructions(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action<Character, int>>((Action<Character, int>)SetSpawnAbilityLevelControl) })
					.ThrowIfNotMatch("Unable to patch TriggerSpawner Spawn set level.", Array.Empty<CodeMatch>());
				return val.Instructions();
			}

			public static void SetSpawnAbilityLevelControl(Character chara, int providedLevel)
			{
				if (ValConfig.ControlAbilitySpawnedCreatures.Value)
				{
					CreatureSetupControl.CreatureSpawnerSetup(chara);
				}
				else
				{
					chara.SetLevel(providedLevel);
				}
			}
		}

		[HarmonyPatch(typeof(EggHatch))]
		public static class EggHatchSpawnPatch
		{
			[HarmonyPatch("Hatch")]
			private static bool Prefix(EggHatch __instance)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				__instance.m_hatchEffect.Create(((Component)__instance).transform.position, ((Component)__instance).transform.rotation, (Transform)null, 1f, -1);
				Character component = Object.Instantiate<GameObject>(__instance.m_spawnPrefab, ((Component)__instance).transform.TransformPoint(__instance.m_spawnOffset), Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f)).GetComponent<Character>();
				if ((Object)(object)component != (Object)null)
				{
					CreatureSetupControl.CreatureSetup(component);
				}
				__instance.m_nview.Destroy();
				return false;
			}
		}

		[HarmonyPatch(typeof(ItemDrop))]
		public static class DropOnDestroyedSpawnPatch
		{
			[HarmonyPostfix]
			[HarmonyPatch("OnCreateNew", new Type[] { typeof(GameObject) })]
			private static void Postfix(GameObject go)
			{
				Character component = go.GetComponent<Character>();
				if ((Object)(object)component != (Object)null)
				{
					CreatureSetupControl.CreatureSetup(component);
				}
			}
		}
	}
	internal static class LevelScalingPatches
	{
		[HarmonyPatch(typeof(Character), "OnDeath")]
		public static class ZoneTracker
		{
			[HarmonyPrefix]
			private static void TrackZoneDeath(Character __instance)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				ZoneScaleSystem.OnCreatureKilled(((Component)__instance).transform.position);
			}
		}

		[HarmonyPatch(typeof(ZNet), "SaveWorld")]
		public static class ZoneDataSaveFlush
		{
			[HarmonyPrefix]
			private static void FlushZoneData()
			{
				ZoneScaleSystemData.FlushPendingSave();
			}
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		public static class ZoneWorldUnload
		{
			[HarmonyPrefix]
			private static void ResetZonesOnLeave()
			{
				ZoneScaleSystem.ResetForWorldChange();
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		public static class DedicatedServerZoneInit
		{
			[HarmonyPostfix]
			private static void InitZonesOnServer()
			{
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsDedicated())
				{
					ZoneScaleSystem.Initialize();
				}
			}
		}

		[HarmonyPatch(typeof(Player), "AddUniqueKey")]
		internal static class UpdatePlayerPrivateKeys
		{
			public static void Postfix()
			{
				ConditionalScaleSystem.ResetCache();
			}
		}

		[HarmonyPatch(typeof(Player), "RemoveUniqueKey")]
		internal static class RemovePlayerPrivateKey
		{
			public static void Postfix()
			{
				ConditionalScaleSystem.ResetCache();
			}
		}
	}
	internal static class LevelSelection
	{
		public static int GetMaxCreatureLevel(Character character, DataObjects.CreatureSpecificSetting creature_settings = null, DataObjects.BiomeSpecificSetting biome_settings = null)
		{
			int num = (((Object)(object)character != (Object)null && character.IsBoss()) ? ValConfig.MaxBossLevel.Value : ValConfig.MaxLevel.Value);
			if (biome_settings != null && biome_settings.BiomeMaxLevelOverride != 0)
			{
				num = biome_settings.BiomeMaxLevelOverride;
			}
			if (creature_settings != null && creature_settings.CreatureMaxLevelOverride > -1)
			{
				num = creature_settings.CreatureMaxLevelOverride;
			}
			return num + 1;
		}

		public static int DetermineLevel(Character character, ZDO cZDO, DataObjects.CreatureSpecificSetting creature_settings, DataObjects.BiomeSpecificSetting biome_settings, Biome biome, int leveloverride = 0, bool allowRoll = true)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || cZDO == null)
			{
				Logger.LogWarning("Creature null or nview null, cannot set level.");
				return 1;
			}
			if (leveloverride > 0)
			{
				Logger.LogDebug($"Level override provided, setting level to {leveloverride}");
				return leveloverride;
			}
			int num = cZDO.GetInt(ZDOVars.s_level, 0);
			int maxCreatureLevel = GetMaxCreatureLevel(character, creature_settings, biome_settings);
			if (num <= 0 || (ValConfig.OverLevelCreaturesGetRerolledOnLoad.Value && num > maxCreatureLevel))
			{
				if (!allowRoll)
				{
					if (num > 0)
					{
						return num;
					}
					return 0;
				}
				int num2 = 0;
				SortedDictionary<int, float> conditionalLevelupChance = ConditionalScaleSystem.GetConditionalLevelupChance(biome);
				if (biome_settings != null && biome_settings.BiomeMinLevelOverride > 0)
				{
					num2 = biome_settings.BiomeMinLevelOverride;
				}
				if (creature_settings != null && creature_settings.CreatureMinLevelOverride > -1)
				{
					num2 = creature_settings.CreatureMinLevelOverride;
				}
				num2++;
				float roll = Random.Range(0f, 100f);
				float distance_influence = 1f;
				SortedDictionary<int, float> levelup_bonus = DetermineDistanceBonus(((Component)character).transform.position);
				SortedDictionary<int, float> creature_levelup_chance = DetermineLevelupChance(creature_settings, biome_settings, conditionalLevelupChance);
				if (biome_settings != null)
				{
					distance_influence = biome_settings.DistanceScaleModifier;
				}
				if (creature_settings != null && creature_settings.DistanceScaleModifier != 1f)
				{
					distance_influence = creature_settings.DistanceScaleModifier;
				}
				float nightBonus = 1f;
				if (biome_settings != null && biome_settings.NightSettings != null && biome_settings.NightSettings.NightLevelUpChanceScaler != 1f)
				{
					nightBonus = biome_settings.NightSettings.NightLevelUpChanceScaler;
				}
				if (creature_settings != null && creature_settings.NightSettings != null && creature_settings.NightSettings.NightLevelUpChanceScaler != 1f)
				{
					nightBonus = creature_settings.NightSettings.NightLevelUpChanceScaler;
				}
				float zoneBonus = 1f;
				if (ValConfig.EnableZoneScalingBonus.Value)
				{
					DataObjects.ZoneData zoneForPosition = ZoneScaleSystemData.GetZoneForPosition(((Component)character).transform.position);
					if (zoneForPosition != null)
					{
						zoneBonus = zoneForPosition.GetLevelBonus();
					}
				}
				int num3 = DetermineLevelRollResult(roll, maxCreatureLevel, creature_levelup_chance, levelup_bonus, distance_influence, nightBonus, zoneBonus);
				if (num2 > 0 && num3 < num2)
				{
					num3 = num2;
				}
				if (ValConfig.EnableNemesisSystem.Value)
				{
					num3 = NemesisActions.LevelSystemDetermineNemesisInfluence(character, num2, maxCreatureLevel, num3);
				}
				return num3;
			}
			return num;
		}

		public static int DetermineLevel(GameObject creature, string creature_name, DataObjects.CreatureSpecificSetting creature_settings, DataObjects.BiomeSpecificSetting biome_settings, int maxLevel)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)creature == (Object)null)
			{
				Logger.LogWarning("Creature is null, cannot determine level, set 1.");
				return 1;
			}
			float roll = Random.Range(0f, 100f);
			maxLevel++;
			Vector3 position = creature.transform.position;
			float distance_from_center = Vector2.Distance(new Vector2(position.x, position.z), new Vector2(DistanceScaleSystem.center.x, DistanceScaleSystem.center.z));
			SortedDictionary<int, float> levelup_bonus = new SortedDictionary<int, float>();
			SortedDictionary<int, float> sortedDictionary = LevelSystemData.SLE_Level_Settings.DefaultCreatureLevelUpChance;
			if (sortedDictionary == null)
			{
				sortedDictionary = LevelSystemData.DefaultConfiguration.DefaultCreatureLevelUpChance;
			}
			if (ValConfig.EnableDistanceLevelScalingBonus.Value && LevelSystemData.SLE_Level_Settings.DistanceLevelBonus != null)
			{
				levelup_bonus = DistanceScaleSystem.SelectDistanceFromCenterLevelBonus(distance_from_center);
			}
			float distance_influence = 1f;
			if (biome_settings != null)
			{
				distance_influence = biome_settings.DistanceScaleModifier;
			}
			if (creature_settings != null && creature_settings.DistanceScaleModifier != 1f)
			{
				distance_influence = creature_settings.DistanceScaleModifier;
			}
			if (LevelSystemData.SLE_Level_Settings.CreatureConfiguration != null && LevelSystemData.SLE_Level_Settings.CreatureConfiguration.ContainsKey(creature_name) && creature_settings.CustomCreatureLevelUpChance != null)
			{
				if (creature_settings.CreatureMaxLevelOverride > -1)
				{
					maxLevel = creature_settings.CreatureMaxLevelOverride;
				}
				if (creature_settings.CustomCreatureLevelUpChance != null)
				{
					sortedDictionary = creature_settings.CustomCreatureLevelUpChance;
				}
				return DetermineLevelRollResult(roll, maxLevel, sortedDictionary, levelup_bonus, distance_influence);
			}
			if (biome_settings != null)
			{
				if (biome_settings.BiomeMaxLevelOverride > 0)
				{
					maxLevel = biome_settings.BiomeMaxLevelOverride;
				}
				if (biome_settings.CustomCreatureLevelUpChance != null)
				{
					sortedDictionary = biome_settings.CustomCreatureLevelUpChance;
				}
				return DetermineLevelRollResult(roll, maxLevel, sortedDictionary, levelup_bonus, distance_influence);
			}
			return DetermineLevelRollResult(roll, maxLevel, sortedDictionary, levelup_bonus, distance_influence);
		}

		public static SortedDictionary<int, float> DetermineLevelupChance(DataObjects.CreatureSpecificSetting creature_settings = null, DataObjects.BiomeSpecificSetting biome_settings = null, SortedDictionary<int, float> customLevelup = null)
		{
			SortedDictionary<int, float> sortedDictionary = LevelSystemData.SLE_Level_Settings.DefaultCreatureLevelUpChance;
			if (sortedDictionary == null)
			{
				sortedDictionary = LevelSystemData.DefaultConfiguration.DefaultCreatureLevelUpChance;
			}
			if (customLevelup != null)
			{
				sortedDictionary = customLevelup;
			}
			if (biome_settings != null && biome_settings.CustomCreatureLevelUpChance != null)
			{
				sortedDictionary = biome_settings.CustomCreatureLevelUpChance;
			}
			if (creature_settings != null && creature_settings.CustomCreatureLevelUpChance != null)
			{
				sortedDictionary = creature_settings.CustomCreatureLevelUpChance;
			}
			return sortedDictionary;
		}

		public static SortedDictionary<int, float> DetermineDistanceBonus(Vector3 pos)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			SortedDictionary<int, float> result = new SortedDictionary<int, float>();
			if (!ValConfig.EnableDistanceLevelScalingBonus.Value || !LevelSystemData.SLE_Level_Settings.EnableDistanceLevelBonus)
			{
				return result;
			}
			float distance_from_center = Vector2.Distance(new Vector2(pos.x, pos.z), new Vector2(DistanceScaleSystem.center.x, DistanceScaleSystem.center.z));
			if (LevelSystemData.SLE_Level_Settings.DistanceLevelBonus != null)
			{
				result = DistanceScaleSystem.SelectDistanceFromCenterLevelBonus(distance_from_center);
			}
			return result;
		}

		public static void SetAndUpdateCharacterLevel(Character character, int level)
		{
			if (!((Object)(object)character == (Object)null))
			{
				character.m_level = level;
				character.SetupMaxHealth();
				if ((Object)(object)character.m_nview != (Object)null && character.m_nview.GetZDO() != null)
				{
					character.m_nview.GetZDO().Set(ZDOVars.s_level, level, false);
				}
			}
		}

		public static int DetermineLevelRollResult(float roll, int maxLevel, SortedDictionary<int, float> creature_levelup_chance, SortedDictionary<int, float> levelup_bonus, float distance_influence, float nightBonus = 1f, float zoneBonus = 1f)
		{
			int num = 0;
			SortedDictionary<int, float> sortedDictionary = new SortedDictionary<int, float>();
			Extensions.AddRange<int, float>((IDictionary<int, float>)sortedDictionary, (IDictionary<int, float>)creature_levelup_chance);
			if (levelup_bonus != null)
			{
				foreach (KeyValuePair<int, float> levelup_bonu in levelup_bonus)
				{
					if (sortedDictionary.ContainsKey(levelup_bonu.Key))
					{
						sortedDictionary[levelup_bonu.Key] += levelup_bonu.Value * distance_influence;
					}
					else
					{
						sortedDictionary[levelup_bonu.Key] = levelup_bonu.Value * distance_influence;
					}
				}
			}
			int num2 = 0;
			foreach (KeyValuePair<int, float> item in sortedDictionary)
			{
				float num3 = item.Value * nightBonus * zoneBonus;
				num2++;
				if (!(roll >= num3) && item.Key < maxLevel && num2 != sortedDictionary.Count())
				{
					continue;
				}
				num = item.Key;
				if (ValConfig.EnableDebugOutputLevelRolls.Value)
				{
					if (num2 == sortedDictionary.Count())
					{
						num++;
					}
					float num4 = 0f;
					if (levelup_bonus != null && levelup_bonus.ContainsKey(item.Key))
					{
						num4 = levelup_bonus[item.Key];
					}
					float num5 = 0f;
					if (creature_levelup_chance.ContainsKey(item.Key))
					{
						num5 = creature_levelup_chance[item.Key];
					}
					Logger.LogDebug($"Level Roll: {roll} >= {num3} = [ {num5}(base) + {num4}(distanceBonus) * {distance_influence}(DistanceInfluence)] * {nightBonus}(Night) * {zoneBonus}(Zone) | max-level used: {maxLevel} Selected Level: {num}");
				}
				break;
			}
			return num;
		}

		public static int DeterministicDetermineTreeLevel(GameObject go)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!ValConfig.EnableTreeScaling.Value)
			{
				return 1;
			}
			Vector3 position = go.transform.position;
			int num = Mathf.RoundToInt(Vector2.Distance(new Vector2(position.x, position.z), new Vector2(DistanceScaleSystem.center.x, DistanceScaleSystem.center.z)) / (10000f / (float)ValConfig.TreeMaxLevel.Value));
			if (num < 1)
			{
				num = 1;
			}
			return num;
		}

		public static int DeterministicDetermineRockLevel(Vector3 pos)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!ValConfig.EnableRockLevels.Value)
			{
				return 1;
			}
			int num = Mathf.RoundToInt(Vector2.Distance(new Vector2(pos.x, pos.z), new Vector2(DistanceScaleSystem.center.x, DistanceScaleSystem.center.z)) / (10000f / (float)ValConfig.RockMaxLevel.Value));
			if (num < 1)
			{
				num = 1;
			}
			return num;
		}

		public static int DetermineisticDetermineObjectLevel(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.RoundToInt(Vector2.Distance(new Vector2(pos.x, pos.z), new Vector2(DistanceScaleSystem.center.x, DistanceScaleSystem.center.z)) / (10000f / (float)ValConfig.DestructibleMaxLevel.Value));
			if (num < 1)
			{
				num = 1;
			}
			return num;
		}

		internal static void SetCharacterLevelControl(Character chara, int fallbackLevel)
		{
			if (!((Object)(object)chara == (Object)null))
			{
				if (ValConfig.ControlSpawnerLevels.Value)
				{
					CreatureSetupControl.CreatureSpawnerSetup(chara, 0, multiply: true, 1f);
					return;
				}
				Logger.LogDebug($"Setting creature level from fallback provided {fallbackLevel}");
				chara.m_nview.GetZDO().Set(ZDOVars.s_level, fallbackLevel, false);
			}
		}

		public static void SelectCreatureBiomeSettings(GameObject creature, out string creature_name, out DataObjects.CreatureSpecificSetting creature_settings, out DataObjects.BiomeSpecificSetting biome_settings, out Biome creature_biome)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected I4, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = creature.transform.position;
			creature_name = Utils.GetPrefabName(creature.gameObject);
			Biome val = Heightmap.FindBiome(position);
			creature_biome = (Biome)(int)val;
			biome_settings = null;
			creature_settings = null;
			if (LevelSystemData.SLE_Level_Settings == null)
			{
				return;
			}
			if (LevelSystemData.SLE_Level_Settings.BiomeConfiguration != null)
			{
				DataObjects.BiomeSpecificSetting value;
				bool flag = LevelSystemData.SLE_Level_Settings.BiomeConfiguration.TryGetValue((Biome)895, out value);
				if (flag)
				{
					biome_settings = value;
				}
				DataObjects.BiomeSpecificSetting value2;
				bool flag2 = LevelSystemData.SLE_Level_Settings.BiomeConfiguration.TryGetValue(val, out value2);
				if (flag2 && flag)
				{
					biome_settings = SLSExtensions.MutatingMergeBiomeConfigs(value2, value);
				}
				else if (flag2)
				{
					biome_settings = value2;
				}
			}
			if (LevelSystemData.SLE_Level_Settings.CreatureConfiguration != null && LevelSystemData.SLE_Level_Settings.CreatureConfiguration.TryGetValue(creature_name, out var value3))
			{
				creature_settings = value3;
			}
		}

		public static IEnumerator ModifyTreeWithLevel(TreeBase tree, int level)
		{
			yield return (object)new WaitForSeconds(1f);
			if ((Object)(object)tree == (Object)null)
			{
				yield break;
			}
			float num = 1f + ValConfig.TreeSizeScalePerLevel.Value * (float)level;
			tree.m_health += tree.m_health * 0.1f * (float)level;
			Transform transform = ((Component)tree).transform;
			transform.localScale *= num;
			List<DropData> list = new List<DropData>();
			foreach (DropData drop in tree.m_dropWhenDestroyed.m_drops)
			{
				DropData item = new DropData
				{
					m_stackMin = Mathf.RoundToInt((float)drop.m_stackMin * (1f + ValConfig.PerLevelTreeLootScale.Value * (float)level)),
					m_stackMax = Mathf.RoundToInt((float)drop.m_stackMax * (1f + ValConfig.PerLevelTreeLootScale.Value * (float)level)),
					m_item = drop.m_item
				};
				list.Add(item);
			}
			Physics.SyncTransforms();
		}
	}
	internal static class MinimapOverlayFog
	{
		[HarmonyPatch(typeof(Minimap), "Explore", new Type[]
		{
			typeof(int),
			typeof(int)
		})]
		internal static class Minimap_Explore_Patch
		{
			private static void Postfix(bool __result)
			{
				if (__result)
				{
					ExplorationChanged = true;
				}
			}
		}

		internal static bool ExplorationChanged;

		private static float nextFogRefresh;

		private const float FogRefreshInterval = 10f;

		internal static bool CanDrawOverlays()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance != (Object)null && (Object)(object)Minimap.instance != (Object)null)
			{
				Scene activeScene = SceneManager.GetActiveScene();
				return ((Scene)(ref activeScene)).name == "main";
			}
			return false;
		}

		internal static bool IsPixelExplored(int px, int py)
		{
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null || instance.m_explored == null)
			{
				return true;
			}
			int textureSize = instance.m_textureSize;
			if (px < 0 || py < 0 || px >= textureSize || py >= textureSize)
			{
				return false;
			}
			int num = py * textureSize + px;
			if (!instance.m_explored[num])
			{
				return instance.m_exploredOthers[num];
			}
			return true;
		}

		internal static void MaybeRefreshForExploration()
		{
			if (!ExplorationChanged || Time.unscaledTime < nextFogRefresh)
			{
				return;
			}
			nextFogRefresh = Time.unscaledTime + 10f;
			if (!CanDrawOverlays())
			{
				return;
			}
			bool flag = ValConfig.EnableMapRingsForDistanceBonus.Value && !ValConfig.MapRingsAboveFog.Value;
			bool flag2 = ValConfig.EnableZoneScalingBonus.Value && ValConfig.EnableZoneMapOverlay.Value && !ValConfig.ZoneOverlayAboveFog.Value;
			if (flag || flag2)
			{
				ExplorationChanged = false;
				if (flag)
				{
					DistanceScaleSystem.DelayedMinimapSetup();
				}
				if (flag2)
				{
					ZoneScaleSystem.DrawMinimapOverlay();
				}
			}
		}
	}
	internal static class UpdateLevelsOnChange
	{
		public static void ModifyLoadedCreatureLevels(object s, EventArgs e)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && ZNetScene.instance.IsAreaReady(((Component)Player.m_localPlayer).gameObject.transform.position))
			{
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(ModifyLoadedCreaturesLevels());
			}
		}

		public static void UpdateFishMaxLevel()
		{
			if (!ValConfig.EnableScalingFish.Value)
			{
				return;
			}
			foreach (GameObject item in from obj in Resources.FindObjectsOfTypeAll<GameObject>()
				where ((Object)obj).name.StartsWith("Fish")
				select obj)
			{
				if ((Object)(object)item.GetComponent<Fish>() != (Object)null)
				{
					item.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality = ValConfig.FishMaxLevel.Value + 1;
				}
			}
		}

		public static IEnumerator ModifyLoadedCreaturesLevels()
		{
			int updated = 0;
			IEnumerable<GameObject> enumerable = from obj in Resources.FindObjectsOfTypeAll<GameObject>()
				where (Object)(object)obj.GetComponent<Character>() != (Object)null || Object.op_Implicit((Object)(object)obj.GetComponent<Humanoid>())
				select obj;
			foreach (GameObject creature in enumerable)
			{
				updated++;
				if (updated % ValConfig.NumberOfCacheUpdatesPerFrame.Value == 0)
				{
					yield return (object)new WaitForEndOfFrame();
					Physics.SyncTransforms();
				}
				if (!((Object)(object)creature == (Object)null))
				{
					Character component = creature.GetComponent<Character>();
					if ((Object)(object)component == (Object)null)
					{
						component = (Character)(object)creature.GetComponent<Humanoid>();
					}
					if (!((Object)(object)component == (Object)null) && !((Object)(object)component.m_nview == (Object)null) && component.m_nview.GetZDO() != null && component.GetLevel() > ValConfig.MaxLevel.Value)
					{
						DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(component, 0, null, null, updateCache: true);
						CreatureSetupControl.CreatureSetup(component, andSetLocalCache.Level);
					}
				}
			}
		}

		public static void UpdateTreeSizeOnConfigChange(object s, EventArgs e)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && ZNetScene.instance.IsAreaReady(((Component)Player.m_localPlayer).gameObject.transform.position))
			{
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(UpdateAllTreeSizesOnConfigChangeCoroutine());
			}
		}

		public static void UpdateBirdSizeOnConfigChange(object s, EventArgs e)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && ZNetScene.instance.IsAreaReady(((Component)Player.m_localPlayer).gameObject.transform.position))
			{
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(UpdateAllBirdSizesOnConfigChangeCoroutine());
			}
		}

		public static void UpdateFishSizeOnConfigChange(object s, EventArgs e)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && ZNetScene.instance.IsAreaReady(((Component)Player.m_localPlayer).gameObject.transform.position))
			{
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(UpdateAllFishOnConfigChangeCoroutine());
			}
		}

		public static IEnumerator UpdateAllTreeSizesOnConfigChangeCoroutine()
		{
			int updated = 0;
			IEnumerable<GameObject> enumerable = from obj in Resources.FindObjectsOfTypeAll<GameObject>()
				where (Object)(object)obj.GetComponent<TreeBase>() != (Object)null
				select obj;
			foreach (GameObject tree in enumerable)
			{
				updated++;
				if (updated % ValConfig.NumberOfCacheUpdatesPerFrame.Value == 0)
				{
					yield return (object)new WaitForEndOfFrame();
					Physics.SyncTransforms();
				}
				TreeBase component = tree.GetComponent<TreeBase>();
				if ((Object)(object)component == (Object)null || (Object)(object)component.m_nview == (Object)null || component.m_nview.GetZDO() == null)
				{
					continue;
				}
				string prefabName = Utils.GetPrefabName(tree.gameObject);
				Vector3 val = component.m_nview.GetZDO().GetVec3(ZDOVars.s_scaleHash, Vector3.zero);
				if (val == Vector3.zero)
				{
					float num = component.m_nview.GetZDO().GetFloat(ZDOVars.s_scaleScalarHash, 0f);
					((Vector3)(ref val))..ctor(num, num, num);
				}
				if (val == Vector3.zero)
				{
					val = PrefabManager.Instance.GetPrefab(prefabName).gameObject.transform.localScale;
				}
				if (!ValConfig.EnableTreeScaling.Value)
				{
					((Component)component).transform.localScale = val;
					continue;
				}
				if (ValConfig.UseDeterministicTreeScaling.Value)
				{
					float num2 = 1f + ValConfig.TreeSizeScalePerLevel.Value * (float)CompositeLazyCache.GetOrAddCachedTreeEntry(component.m_nview);
					((Component)component).transform.localScale = val * num2;
					continue;
				}
				int num3 = component.m_nview.GetZDO().GetInt(DataObjects.SLS_TREE, 0);
				if (num3 > 1)
				{
					float num4 = 1f + ValConfig.TreeSizeScalePerLevel.Value * (float)num3;
					((Component)component).transform.localScale = val * num4;
				}
			}
		}

		public static IEnumerator UpdateAllBirdSizesOnConfigChangeCoroutine()
		{
			int updated = 0;
			Dictionary<string, Vector3> BirdSizeReferences = new Dictionary<string, Vector3>();
			IEnumerable<GameObject> enumerable = from obj in Resources.FindObjectsOfTypeAll<GameObject>()
				where (Object)(object)obj.GetComponent<RandomFlyingBird>() != (Object)null
				select obj;
			foreach (GameObject bird in enumerable)
			{
				updated++;
				if (updated % ValConfig.NumberOfCacheUpdatesPerFrame.Value == 0)
				{
					yield return (object)new WaitForEndOfFrame();
					Physics.SyncTransforms();
				}
				RandomFlyingBird component = bird.GetComponent<RandomFlyingBird>();
				if ((Object)(object)component == (Object)null || (Object)(object)component.m_nview == (Object)null || component.m_nview.GetZDO() == null)
				{
					continue;
				}
				string prefabName = Utils.GetPrefabName(bird.gameObject);
				if (!BirdSizeReferences.ContainsKey(prefabName))
				{
					BirdSizeReferences.Add(prefabName, PrefabManager.Instance.GetPrefab(prefabName).gameObject.transform.localScale);
				}
				if (!ValConfig.EnableScalingBirds.Value)
				{
					((Component)component).transform.localScale = BirdSizeReferences[prefabName];
					continue;
				}
				int num = component.m_nview.GetZDO().GetInt(DataObjects.SLS_BIRD, 0);
				if (num > 1)
				{
					float num2 = 1f + ValConfig.BirdSizeScalePerLevel.Value * (float)num;
					((Component)component).transform.localScale = BirdSizeReferences[prefabName] * num2;
				}
			}
		}

		public static IEnumerator UpdateAllFishOnConfigChangeCoroutine()
		{
			int updated = 0;
			Dictionary<string, Vector3> FishSizeReference = new Dictionary<string, Vector3>();
			IEnumerable<GameObject> enumerable = from obj in Resources.FindObjectsOfTypeAll<GameObject>()
				where (Object)(object)obj.GetComponent<Fish>() != (Object)null
				select obj;
			foreach (GameObject fish in enumerable)
			{
				updated++;
				if (updated % ValConfig.NumberOfCacheUpdatesPerFrame.Value == 0)
				{
					yield return (object)new WaitForEndOfFrame();
					Physics.SyncTransforms();
				}
				Fish component = fish.GetComponent<Fish>();
				if ((Object)(object)component == (Object)null || (Object)(object)component.m_nview == (Object)null || component.m_nview.GetZDO() == null)
				{
					continue;
				}
				string prefabName = Utils.GetPrefabName(fish.gameObject);
				if (!FishSizeReference.ContainsKey(prefabName))
				{
					FishSizeReference.Add(prefabName, PrefabManager.Instance.GetPrefab(prefabName).gameObject.transform.localScale);
				}
				if (!ValConfig.EnableScalingFish.Value)
				{
					((Component)component).transform.localScale = FishSizeReference[prefabName];
					continue;
				}
				int num = component.m_nview.GetZDO().GetInt(DataObjects.SLS_FISH, 0);
				if (num > 1)
				{
					float num2 = 1f + ValConfig.FishSizeScalePerLevel.Value * (float)num;
					((Component)component).transform.localScale = FishSizeReference[prefabName] * num2;
					continue;
				}
				ItemDrop component2 = fish.GetComponent<ItemDrop>();
				if (component2.m_itemData.m_quality > 1)
				{
					float num3 = 1f + ValConfig.FishSizeScalePerLevel.Value * (float)component2.m_itemData.m_quality;
					((Component)component).transform.localScale = FishSizeReference[prefabName] * num3;
					component2.m_itemData.m_shared.m_scaleByQuality = ValConfig.FishSizeScalePerLevel.Value;
					component2.Save();
				}
			}
		}
	}
	internal static class ZoneScaleSystem
	{
		private const float GridResolution = 100f;

		private const string ZoneLayer = "SLS-ZoneLevels";

		private static Color defaultColor = new Color(0.5f, 0.5f, 0.5f, 0.6f);

		private static readonly List<DataObjects.SerializableVector3> pendingDeaths = new List<DataObjects.SerializableVector3>();

		private static bool flushRunning = false;

		private static Coroutine overlayRebuildCoroutine;

		private static Coroutine flushCoroutine;

		private static Coroutine buildCoroutine;

		public static void Initialize()
		{
			if (ValConfig.EnableZoneScalingBonus.Value && !ZoneScaleSystemData.zonesBuilt && !ZoneScaleSystemData.buildingZones)
			{
				if (ZNet.instance.IsDedicated())
				{
					Logger.LogDebug("Server is headless, skipping zone minimap generation.");
				}
				if (ZoneScaleSystemData.LoadZoneData())
				{
					Logger.LogInfo($"Zone data loaded from file. {ZoneScaleSystemData.Zones.Count} zones available.");
					ZoneScaleSystemData.zonesBuilt = true;
					ZoneScaleSystemData.StartDecayCoroutine();
					DrawMinimapOverlay();
				}
				else
				{
					Logger.LogInfo("No zone data found, building zone map from world...");
					ZoneScaleSystemData.buildingZones = true;
					buildCoroutine = ((MonoBehaviour)TaskRunner.Run()).StartCoroutine(BuildZoneMap());
				}
			}
		}

		private static IEnumerator BuildZoneMap()
		{
			Logger.LogInfo("Zone map generation started.");
			yield return (object)new WaitForSeconds(5f);
			if (WorldGenerator.instance == null)
			{
				Logger.LogWarning("WorldGenerator not available, cannot build zone map.");
				ZoneScaleSystemData.buildingZones = false;
				yield break;
			}
			float worldRadius = 10000f;
			int gridDim = Mathf.CeilToInt(worldRadius * 2f / 100f);
			bool[,] landGrid = new bool[gridDim, gridDim];
			int updates = 0;
			for (int gx = 0; gx < gridDim; gx++)
			{
				float wx = 0f - worldRadius + (float)gx * 100f;
				for (int gz = 0; gz < gridDim; gz++)
				{
					float num = 0f - worldRadius + (float)gz * 100f;
					Biome biome = WorldGenerator.instance.GetBiome(new Vector3(wx, 0f, num));
					landGrid[gx, gz] = (int)biome != 256 && (int)biome > 0;
					updates++;
					if (updates % 5000 == 0)
					{
						yield return (object)new WaitForEndOfFrame();
					}
				}
			}
			Logger.LogDebug($"Zone map sampling complete. Grid: {gridDim}x{gridDim}");
			bool[,] visited = new bool[gridDim, gridDim];
			List<List<(int gx, int gz)>> regions = new List<List<(int, int)>>();
			for (int gx = 0; gx < gridDim; gx++)
			{
				for (int gz = 0; gz < gridDim; gz++)
				{
					if (!landGrid[gx, gz] || visited[gx, gz])
					{
						continue;
					}
					List<(int, int)> list = new List<(int, int)>();
					Queue<(int, int)> queue = new Queue<(int, int)>();
					queue.Enqueue((gx, gz));
					visited[gx, gz] = true;
					while (queue.Count > 0)
					{
						var (num2, num3) = queue.Dequeue();
						list.Add((num2, num3));
						foreach (var (num4, num5) in Neighbors(num2, num3))
						{
							if (num4 >= 0 && num4 < gridDim && num5 >= 0 && num5 < gridDim && !visited[num4, num5] && landGrid[num4, num5])
							{
								visited[num4, num5] = true;
								queue.Enqueue((num4, num5));
							}
						}
					}
					regions.Add(list);
					if (regions.Count % 10 == 0)
					{
						yield return (object)new WaitForEndOfFrame();
					}
				}
			}
			Logger.LogDebug($"Found {regions.Count} connected land regions.");
			float value = ValConfig.MaxZoneSize.Value;
			Dictionary<long, DataObjects.ZoneData> dictionary = new Dictionary<long, DataObjects.ZoneData>();
			foreach (List<(int, int)> item3 in regions)
			{
				int num6 = item3.Min<(int, int)>(((int gx, int gz) r) => r.gx);
				int num7 = item3.Max<(int, int)>(((int gx, int gz) r) => r.gx);
				int num8 = item3.Min<(int, int)>(((int gx, int gz) r) => r.gz);
				int num9 = item3.Max<(int, int)>(((int gx, int gz) r) => r.gz);
				float num10 = (float)(num7 - num6 + 1) * 100f;
				float num11 = (float)(num9 - num8 + 1) * 100f;
				if (num10 < ValConfig.MinZoneSize.Value || num11 < ValConfig.MinZoneSize.Value)
				{
					continue;
				}
				foreach (var item4 in item3)
				{
					int item = item4.Item1;
					int item2 = item4.Item2;
					float num12 = 0f - worldRadius + ((float)item + 0.5f) * 100f;
					float num13 = 0f - worldRadius + ((float)item2 + 0.5f) * 100f;
					int num14 = Mathf.FloorToInt((num12 + worldRadius) / value);
					int num15 = Mathf.FloorToInt((num13 + worldRadius) / value);
					long key = (long)(((ulong)(uint)num14 << 32) | (uint)num15);
					if (!dictionary.ContainsKey(key))
					{
						float num16 = 0f - worldRadius + (float)num14 * value;
						float num17 = 0f - worldRadius + (float)num15 * value;
						dictionary[key] = new DataObjects.ZoneData
						{
							ZoneId = ZoneScaleSystemData.ZoneIdForCell(num14, num15),
							MinX = num16,
							MaxX = num16 + value,
							MinZ = num17,
							MaxZ = num17 + value
						};
					}
				}
			}
			List<DataObjects.ZoneData> list2 = dictionary.Values.ToList();
			foreach (DataObjects.ZoneData item5 in list2)
			{
				item5.LastDecayTimestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			}
			ZoneScaleSystemData.Zones = list2;
			ZoneScaleSystemData.BuildZoneIndex();
			ZoneScaleSystemData.zonesBuilt = true;
			ZoneScaleSystemData.buildingZones = false;
			Logger.LogInfo($"Zone map built: {ZoneScaleSystemData.Zones.Count} zones created.");
			ZoneScaleSystemData.SaveZoneData();
			ZoneScaleSystemData.StartDecayCoroutine();
			DrawMinimapOverlay();
		}

		internal static void RebuildZones()
		{
			if (!ValConfig.EnableZoneScalingBonus.Value)
			{
				Logger.LogInfo("Zone scaling is disabled (EnableZoneScalingBonus=false); nothing to rebuild.");
				return;
			}
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				Logger.LogInfo("Not in a world; cannot rebuild zones.");
				return;
			}
			if (ZoneScaleSystemData.buildingZones)
			{
				Logger.LogInfo("Zone map is already building; please wait.");
				return;
			}
			if (ZoneScaleSystemData.overlayAvailable && !ZNet.instance.IsDedicated() && MinimapManager.Instance != null)
			{
				MapOverlay mapOverlay = MinimapManager.Instance.GetMapOverlay("SLS-ZoneLevels", ValConfig.ZoneOverlayAboveFog.Value);
				if (mapOverlay != null)
				{
					int num = ((MapOverlayBase)mapOverlay).TextureSize * ((MapOverlayBase)mapOverlay).TextureSize;
					mapOverlay.OverlayTex.SetPixels((Color[])(object)new Color[num]);
					mapOverlay.OverlayTex.Apply();
				}
			}
			ZoneScaleSystemData.Zones = new List<DataObjects.ZoneData>();
			ZoneScaleSystemData.BuildZoneIndex();
			ZoneScaleSystemData.zonesBuilt = false;
			ZoneScaleSystemData.overlayAvailable = false;
			ZoneScaleSystemData.buildingZones = true;
			Logger.LogInfo("Rebuilding zone map from world...");
			buildCoroutine = ((MonoBehaviour)TaskRunner.Run()).StartCoroutine(BuildZoneMap());
		}

		internal static void ResetForWorldChange()
		{
			Orchestrator orchestrator = TaskRunner.Run();
			if (buildCoroutine != null)
			{
				((MonoBehaviour)orchestrator).StopCoroutine(buildCoroutine);
				buildCoroutine = null;
			}
			if (flushCoroutine != null)
			{
				((MonoBehaviour)orchestrator).StopCoroutine(flushCoroutine);
				flushCoroutine = null;
			}
			if (overlayRebuildCoroutine != null)
			{
				((MonoBehaviour)orchestrator).StopCoroutine(overlayRebuildCoroutine);
				overlayRebuildCoroutine = null;
			}
			pendingDeaths.Clear();
			flushRunning = false;
			ZoneScaleSystemData.ResetState();
		}

		private static IEnumerable<(int, int)> Neighbors(int x, int z)
		{
			yield return (x - 1, z);
			yield return (x + 1, z);
			yield return (x, z - 1);
			yield return (x, z + 1);
		}

		internal static void OnCreatureKilled(Vector3 pos)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (ValConfig.EnableZoneScalingBonus.Value)
			{
				pendingDeaths.Add(pos);
				StartKillReportFlush();
			}
		}

		private static void StartKillReportFlush()
		{
			if (!flushRunning)
			{
				flushRunning = true;
				flushCoroutine = ((MonoBehaviour)TaskRunner.Run()).StartCoroutine(FlushKillReports());
			}
		}

		private static IEnumerator FlushKillReports()
		{
			while (true)
			{
				yield return (object)new WaitForSeconds(ValConfig.KillReportFlushIntervalSeconds.Value);
				if (pendingDeaths.Count == 0)
				{
					continue;
				}
				if ((Object)(object)ZNet.instance == (Object)null)
				{
					pendingDeaths.Clear();
					continue;
				}
				List<DataObjects.SerializableVector3> deaths = new List<DataObjects.SerializableVector3>(pendingDeaths);
				pendingDeaths.Clear();
				if (ZNet.instance.IsServer())
				{
					ZoneScaleSystemData.ApplyDeaths(deaths);
					continue;
				}
				ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
				if (serverPeer != null)
				{
					ValConfig.ZoneKillReportRPC.SendPackage(serverPeer.m_uid, ZoneScaleSystemData.SerializeDeaths(deaths));
				}
			}
		}

		internal static void DrawMinimapOverlay()
		{
			if (ValConfig.EnableZoneMapOverlay.Value && MinimapOverlayFog.CanDrawOverlays() && !ZNet.instance.IsDedicated())
			{
				Orchestrator orchestrator = TaskRunner.Run();
				if (overlayRebuildCoroutine != null)
				{
					((MonoBehaviour)orchestrator).StopCoroutine(overlayRebuildCoroutine);
				}
				overlayRebuildCoroutine = ((MonoBehaviour)orchestrator).StartCoroutine(BuildZoneMapOverlay());
			}
		}

		public static void UpdateZoneOverlayColorsOnChange(object s, EventArgs e)
		{
			Colorization.UpdateZoneOverlayColorSelection();
			if (!((Object)(object)ZNet.instance == (Object)null) && !ZNet.instance.IsDedicated())
			{
				DrawMinimapOverlay();
			}
		}

		public static void UpdateZoneOverlayFogOnChange(object s, EventArgs e)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && !ZNet.instance.IsDedicated())
			{
				DrawMinimapOverlay();
			}
		}

		private static IEnumerator BuildZoneMapOverlay()
		{
			if (!ValConfig.EnableZoneMapOverlay.Value || ZNet.instance.IsDedicated() || !ZoneScaleSystemData.zonesBuilt || ZoneScaleSystemData.Zones.Count == 0 || (Object)(object)Minimap.instance == (Object)null)
			{
				yield break;
			}
			MapOverlay zoneOverlay = MinimapManager.Instance.GetMapOverlay("SLS-ZoneLevels", true);
			if (zoneOverlay == null)
			{
				yield break;
			}
			zoneOverlay.Enabled = true;
			bool aboveFog = ValConfig.ZoneOverlayAboveFog.Value;
			int texSize = ((MapOverlayBase)zoneOverlay).TextureSize;
			int num = texSize * texSize;
			Color[] pixels = (Color[])(object)new Color[num];
			List<Color> colors = Colorization.zoneOverlayColors;
			int num2 = default(int);
			int num3 = default(int);
			Minimap.instance.WorldToPixel(Vector3.zero, ref num2, ref num3);
			int num4 = default(int);
			Minimap.instance.WorldToPixel(new Vector3(5000f, 0f, 0f), ref num4, ref num3);
			float num5 = (float)Mathf.Abs(num4 - num2) / 5000f;
			float outlineInset = ((num5 > 0f) ? (1f / num5) : 0f);
			ZoneScaleSystemData.overlayUpdates = 0;
			foreach (DataObjects.ZoneData zone in ZoneScaleSystemData.Zones)
			{
				Color zoneColor = defaultColor;
				if (zone.ZoneLevel >= 1 && colors != null && colors.Count > 0)
				{
					zoneColor = colors[(zone.ZoneLevel - 1) % colors.Count];
				}
				zoneColor.a = ValConfig.ZoneOverlayColorTransparency.Value;
				float ix0 = zone.MinX + outlineInset;
				float ix1 = zone.MaxX - outlineInset;
				float iz0 = zone.MinZ + outlineInset;
				float iz1 = zone.MaxZ - outlineInset;
				if (ix1 <= ix0 || iz1 <= iz0)
				{
					ix0 = zone.MinX;
					ix1 = zone.MaxX;
					iz0 = zone.MinZ;
					iz1 = zone.MaxZ;
				}
				yield return DrawZoneEdge(pixels, texSize, ix0, iz0, ix1, iz0, zoneColor, aboveFog);
				yield return DrawZoneEdge(pixels, texSize, ix0, iz1, ix1, iz1, zoneColor, aboveFog);
				yield return DrawZoneEdge(pixels, texSize, ix0, iz0, ix0, iz1, zoneColor, aboveFog);
				yield return DrawZoneEdge(pixels, texSize, ix1, iz0, ix1, iz1, zoneColor, aboveFog);
			}
			if (zoneOverlay != null)
			{
				zoneOverlay.OverlayTex.SetPixels(pixels);
				zoneOverlay.OverlayTex.Apply();
				ZoneScaleSystemData.overlayAvailable = true;
				Logger.LogDebug($"Zone map overlay drawn for {ZoneScaleSystemData.Zones.Count} zones.");
			}
		}

		private static IEnumerator DrawZoneEdge(Color[] pixels, int texSize, float x0, float z0, float x1, float z1, Color color, bool aboveFog)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			float dx = x1 - x0;
			float dz = z1 - z0;
			float num = Mathf.Sqrt(dx * dx + dz * dz);
			int steps = Mathf.Max(1, Mathf.CeilToInt(num / 10f));
			int num2 = 1;
			int lo = -(num2 - 1) / 2;
			int hi = num2 / 2;
			int num6 = default(int);
			int num7 = default(int);
			for (int i = 0; i <= steps; i++)
			{
				float num3 = (float)i / (float)steps;
				float num4 = x0 + dx * num3;
				float num5 = z0 + dz * num3;
				Minimap.instance.WorldToPixel(new Vector3(num4, 0f, num5), ref num6, ref num7);
				if (!aboveFog && !MinimapOverlayFog.IsPixelExplored(num6, num7))
				{
					ZoneScaleSystemData.overlayUpdates++;
					if (ZoneScaleSystemData.overlayUpdates % 3000 == 0)
					{
						yield return (object)new WaitForEndOfFrame();
					}
					continue;
				}
				for (int j = lo; j <= hi; j++)
				{
					int num8 = num7 + j;
					if (num8 < 0 || num8 >= texSize)
					{
						continue;
					}
					for (int k = lo; k <= hi; k++)
					{
						int num9 = num6 + k;
						if (num9 >= 0 && num9 < texSize)
						{
							pixels[num8 * texSize + num9] = color;
						}
					}
				}
				ZoneScaleSystemData.overlayUpdates++;
				if (ZoneScaleSystemData.overlayUpdates % 3000 == 0)
				{
					yield return (object)new WaitForEndOfFrame();
				}
			}
		}
	}
}
namespace StarLevelSystem.modules.Health
{
	internal static class HealthModifications
	{
		internal static bool ForceUpdateHealth;

		internal static void ForceApplyHealthModifications(Character chara, DataObjects.CharacterCacheEntry cDetails)
		{
			ForceUpdateHealth = true;
			ApplyHealthModifications(chara, cDetails);
			ForceUpdateHealth = false;
		}

		internal static void ApplyHealthModifications(Character chara, DataObjects.CharacterCacheEntry cDetails)
		{
			float num = chara.m_health;
			if (!chara.IsPlayer() && Game.m_worldLevel > 0)
			{
				num *= (float)Game.m_worldLevel * Game.instance.m_worldLevelEnemyHPMultiplier;
			}
			float maxHealth = chara.GetMaxHealth();
			float maxHealthBase = chara.GetMaxHealthBase();
			float num4;
			if (cDetails.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.BaseHealth] != 1f || cDetails.CreaturePerLevelValueModifiers[DataObjects.CreaturePerLevelAttribute.HealthPerLevel] > 0f)
			{
				float num2 = num * cDetails.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.BaseHealth];
				float num3 = num * cDetails.CreaturePerLevelValueModifiers[DataObjects.CreaturePerLevelAttribute.HealthPerLevel] * (float)(chara.GetLevel() - 1);
				num4 = num2 + num3;
			}
			else
			{
				num = ((!chara.IsBoss()) ? (num * ValConfig.EnemyHealthMultiplier.Value) : (num * ValConfig.BossEnemyHealthMultiplier.Value));
				num4 = num;
			}
			if (!ForceUpdateHealth && maxHealth == num4)
			{
				return;
			}
			float num5 = maxHealthBase * (float)chara.GetLevel();
			if (!ForceUpdateHealth && !ValConfig.OverrideCreatureModifiedHealth.Value && maxHealth != maxHealthBase)
			{
				return;
			}
			if (ValConfig.EnableDebugMode.Value)
			{
				Logger.LogDebug($"Creature {Localization.instance.Localize(cDetails.CreatureNameLocalizable)} HP does not match target: current:{maxHealth} (base {maxHealthBase}) != {num4} | vanilla {num5} | Set to {num4}");
			}
			float health = chara.GetHealth();
			float num6 = maxHealth - health;
			chara.SetMaxHealth(num4);
			if (num6 > 0f)
			{
				float num7 = num4 - num6;
				if (ValConfig.EnableDebugMode.Value && num7 <= 0f)
				{
					Logger.LogDebug($"{Localization.instance.Localize(cDetails.CreatureNameLocalizable)} - lvl:{chara.m_level} will die from health update. New health: {num7}, targetHealth: {num4}, damageTaken: {num6}");
				}
				chara.SetHealth(num7);
			}
			else
			{
				chara.Heal(num4, true);
			}
		}
	}
	internal static class HealthPatches
	{
		[HarmonyPatch(typeof(Character), "Awake")]
		public static class CharacterHealthFix
		{
			private static void Postfix(Character __instance)
			{
				if (float.IsNaN(__instance.GetHealth()))
				{
					Logger.LogWarning("NaN health detected on " + ((Object)__instance).name + ", resetting to max health.");
					__instance.SetHealth(__instance.GetMaxHealth());
				}
			}
		}

		[HarmonyPatch(typeof(Character), "SetHealth")]
		public static class CharacterSetHealthPreventNaN
		{
			private static bool Prefix(Character __instance, float health)
			{
				if (float.IsNaN(health))
				{
					Logger.LogWarning("Preventing NaN health on " + ((Object)__instance).name);
					return false;
				}
				return true;
			}
		}
	}
}
namespace StarLevelSystem.modules.Damage
{
	internal static class DamageModifications
	{
		public static void ForceUpdateDamageMod(Character creature, float increase_dmg_by)
		{
			float num = creature.m_nview.GetZDO().GetFloat(DataObjects.SLS_DAMAGE_MODIFIER, 0f);
			creature.m_nview.GetZDO().Set(DataObjects.SLS_DAMAGE_MODIFIER, num + increase_dmg_by);
		}

		internal static void ApplyDamageModification(Character creature, DataObjects.CharacterCacheEntry cDetails, bool updateCache = false)
		{
			if ((Object)(object)creature.m_nview == (Object)null || cDetails == null)
			{
				return;
			}
			float num = cDetails.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.BaseDamage];
			if (num != 1f)
			{
				DataObjects.DictionaryDmgNetProperty dictionaryDmgNetProperty = new DataObjects.DictionaryDmgNetProperty(DataObjects.SLS_DAMAGE_BONUSES, creature.m_nview, new Dictionary<DataObjects.DamageType, float>());
				if ((dictionaryDmgNetProperty.Get().Count == 0 && cDetails.CreatureDamageBonus.Count > 0) || updateCache)
				{
					dictionaryDmgNetProperty.Set(cDetails.CreatureDamageBonus);
				}
				creature.m_nview.GetZDO().Set(DataObjects.SLS_DAMAGE_MODIFIER, num);
				Logger.LogDebug(string.Format("Built damage buffs for {0} +{1} *{2}", ((Object)creature).name, string.Join(",", cDetails.CreatureDamageBonus), num));
			}
		}

		internal static void ApplyDamageModifiers(HitData hit, Character chara, Dictionary<DataObjects.DamageType, float> damageMods)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Applying damage recieved mods for " + chara.m_name);
			if (hit.m_damage.m_blunt > 0f && damageMods.ContainsKey(DataObjects.DamageType.Blunt))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Blunt}: {hit.m_damage.m_blunt} * {damageMods[DataObjects.DamageType.Blunt]}");
				hit.m_damage.m_blunt *= damageMods[DataObjects.DamageType.Blunt];
				stringBuilder.Append($" = {hit.m_damage.m_blunt}\n");
			}
			if (hit.m_damage.m_pierce > 0f && damageMods.ContainsKey(DataObjects.DamageType.Pierce))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Pierce}: {hit.m_damage.m_pierce} * {damageMods[DataObjects.DamageType.Pierce]}");
				hit.m_damage.m_pierce *= damageMods[DataObjects.DamageType.Pierce];
				stringBuilder.Append($" = {hit.m_damage.m_pierce}\n");
			}
			if (hit.m_damage.m_slash > 0f && damageMods.ContainsKey(DataObjects.DamageType.Slash))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Slash}: {hit.m_damage.m_slash} * {damageMods[DataObjects.DamageType.Slash]}");
				hit.m_damage.m_slash *= damageMods[DataObjects.DamageType.Slash];
				stringBuilder.Append($" = {hit.m_damage.m_slash}\n");
			}
			if (hit.m_damage.m_fire > 0f && damageMods.ContainsKey(DataObjects.DamageType.Fire))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Fire}: {hit.m_damage.m_fire} * {damageMods[DataObjects.DamageType.Fire]}");
				hit.m_damage.m_fire *= damageMods[DataObjects.DamageType.Fire];
				stringBuilder.Append($" = {hit.m_damage.m_fire}\n");
			}
			if (hit.m_damage.m_frost > 0f && damageMods.ContainsKey(DataObjects.DamageType.Frost))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Fire}: {hit.m_damage.m_frost} * {damageMods[DataObjects.DamageType.Frost]}");
				hit.m_damage.m_frost *= damageMods[DataObjects.DamageType.Frost];
				stringBuilder.Append($" = {hit.m_damage.m_frost}\n");
			}
			if (hit.m_damage.m_lightning > 0f && damageMods.ContainsKey(DataObjects.DamageType.Lightning))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Lightning}: {hit.m_damage.m_lightning} * {damageMods[DataObjects.DamageType.Lightning]}");
				hit.m_damage.m_lightning *= damageMods[DataObjects.DamageType.Lightning];
				stringBuilder.Append($" = {hit.m_damage.m_lightning}\n");
			}
			if (hit.m_damage.m_poison > 0f && damageMods.ContainsKey(DataObjects.DamageType.Poison))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Poison}: {hit.m_damage.m_poison} * {damageMods[DataObjects.DamageType.Poison]}");
				hit.m_damage.m_poison *= damageMods[DataObjects.DamageType.Poison];
				stringBuilder.Append($" = {hit.m_damage.m_poison}\n");
			}
			if (hit.m_damage.m_spirit > 0f && damageMods.ContainsKey(DataObjects.DamageType.Spirit))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Spirit}: {hit.m_damage.m_spirit} * {damageMods[DataObjects.DamageType.Spirit]}");
				hit.m_damage.m_spirit *= damageMods[DataObjects.DamageType.Spirit];
				stringBuilder.Append($" = {hit.m_damage.m_spirit}\n");
			}
			if (hit.m_damage.m_chop > 0f && damageMods.ContainsKey(DataObjects.DamageType.Chop))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Spirit}: {hit.m_damage.m_chop} * {damageMods[DataObjects.DamageType.Chop]}");
				hit.m_damage.m_chop *= damageMods[DataObjects.DamageType.Chop];
				stringBuilder.Append($" = {hit.m_damage.m_chop}\n");
			}
			if (hit.m_damage.m_pickaxe > 0f && damageMods.ContainsKey(DataObjects.DamageType.Pickaxe))
			{
				stringBuilder.Append($"  {DataObjects.DamageType.Pickaxe}: {hit.m_damage.m_pickaxe} * {damageMods[DataObjects.DamageType.Pickaxe]}");
				hit.m_damage.m_pickaxe *= damageMods[DataObjects.DamageType.Pickaxe];
				stringBuilder.Append($" = {hit.m_damage.m_pickaxe}\n");
			}
			if (ValConfig.EnableDebugOutputForDamage.Value)
			{
				Logger.LogInfo(stringBuilder.ToString());
			}
		}

		internal static float GetTotalDamageOptions(this HitData hit, bool include_poison = false, bool include_spirit = false, bool include_pickaxe_and_chop = false)
		{
			float num = hit.m_damage.m_damage + hit.m_damage.m_blunt + hit.m_damage.m_slash + hit.m_damage.m_pierce + hit.m_damage.m_fire + hit.m_damage.m_frost + hit.m_damage.m_lightning;
			if (include_poison)
			{
				num += hit.m_damage.m_poison;
			}
			if (include_spirit)
			{
				num += hit.m_damage.m_spirit;
			}
			if (include_pickaxe_and_chop)
			{
				num += hit.m_damage.m_pickaxe + hit.m_damage.m_chop;
			}
			return num;
		}

		internal static void AddDamagesToHit(HitData hit, Dictionary<DataObjects.DamageType, float> damageBonuses)
		{
			float totalDamageOptions = hit.GetTotalDamageOptions();
			foreach (KeyValuePair<DataObjects.DamageType, float> damageBonuse in damageBonuses)
			{
				switch (damageBonuse.Key)
				{
				case DataObjects.DamageType.Blunt:
					hit.m_damage.m_blunt += totalDamageOptions * damageBonuse.Value;
					break;
				case DataObjects.DamageType.Slash:
					hit.m_damage.m_slash += totalDamageOptions * damageBonuse.Value;
					break;
				case DataObjects.DamageType.Pierce:
					hit.m_damage.m_pierce += totalDamageOptions * damageBonuse.Value;
					break;
				case DataObjects.DamageType.Fire:
					hit.m_damage.m_fire += totalDamageOptions * damageBonuse.Value;
					break;
				case DataObjects.DamageType.Frost:
					hit.m_damage.m_frost += totalDamageOptions * damageBonuse.Value;
					break;
				case DataObjects.DamageType.Lightning:
					hit.m_damage.m_lightning += totalDamageOptions * damageBonuse.Value;
					break;
				case DataObjects.DamageType.Poison:
					hit.m_damage.m_poison += totalDamageOptions * damageBonuse.Value;
					break;
				case DataObjects.DamageType.Spirit:
					hit.m_damage.m_spirit += totalDamageOptions * damageBonuse.Value;
					break;
				case DataObjects.DamageType.Chop:
					hit.m_damage.m_chop += totalDamageOptions * damageBonuse.Value;
					break;
				case DataObjects.DamageType.Pickaxe:
					hit.m_damage.m_pickaxe += totalDamageOptions * damageBonuse.Value;
					break;
				}
			}
		}

		internal static Dictionary<DataObjects.DamageType, float> DetermineCreatureDamageRecievedModifiers(DataObjects.BiomeSpecificSetting biome_settings, DataObjects.CreatureSpecificSetting creature_settings)
		{
			Dictionary<DataObjects.DamageType, float> dictionary = new Dictionary<DataObjects.DamageType, float>
			{
				{
					DataObjects.DamageType.Blunt,
					1f
				},
				{
					DataObjects.DamageType.Pierce,
					1f
				},
				{
					DataObjects.DamageType.Slash,
					1f
				},
				{
					DataObjects.DamageType.Fire,
					1f
				},
				{
					DataObjects.DamageType.Frost,
					1f
				},
				{
					DataObjects.DamageType.Lightning,
					1f
				},
				{
					DataObjects.DamageType.Poison,
					1f
				},
				{
					DataObjects.DamageType.Spirit,
					1f
				}
			};
			if (biome_settings != null && biome_settings.DamageRecievedModifiers != null)
			{
				foreach (KeyValuePair<DataObjects.DamageType, float> damageRecievedModifier in biome_settings.DamageRecievedModifiers)
				{
					dictionary[damageRecievedModifier.Key] = damageRecievedModifier.Value;
				}
			}
			if (creature_settings != null && creature_settings.DamageRecievedModifiers != null)
			{
				foreach (KeyValuePair<DataObjects.DamageType, float> damageRecievedModifier2 in creature_settings.DamageRecievedModifiers)
				{
					dictionary[damageRecievedModifier2.Key] = damageRecievedModifier2.Value;
				}
			}
			return dictionary;
		}

		internal static Dictionary<DataObjects.CreaturePerLevelAttribute, float> DetermineCharacterPerLevelStats(DataObjects.BiomeSpecificSetting biome_settings, DataObjects.CreatureSpecificSetting creature_settings)
		{
			Dictionary<DataObjects.CreaturePerLevelAttribute, float> dictionary = new Dictionary<DataObjects.CreaturePerLevelAttribute, float>
			{
				{
					DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
					0f
				},
				{
					DataObjects.CreaturePerLevelAttribute.HealthPerLevel,
					ValConfig.EnemyHealthMultiplier.Value
				},
				{
					DataObjects.CreaturePerLevelAttribute.SizePerLevel,
					ValConfig.PerLevelScaleBonus.Value
				},
				{
					DataObjects.CreaturePerLevelAttribute.SpeedPerLevel,
					0f
				},
				{
					DataObjects.CreaturePerLevelAttribute.AttackSpeedPerLevel,
					0f
				}
			};
			if (biome_settings != null && biome_settings.CreaturePerLevelValueModifiers != null)
			{
				foreach (KeyValuePair<DataObjects.CreaturePerLevelAttribute, float> creaturePerLevelValueModifier in biome_settings.CreaturePerLevelValueModifiers)
				{
					dictionary[creaturePerLevelValueModifier.Key] = creaturePerLevelValueModifier.Value;
				}
			}
			if (creature_settings != null && creature_settings.CreaturePerLevelValueModifiers != null)
			{
				foreach (KeyValuePair<DataObjects.CreaturePerLevelAttribute, float> creaturePerLevelValueModifier2 in creature_settings.CreaturePerLevelValueModifiers)
				{
					dictionary[creaturePerLevelValueModifier2.Key] = creaturePerLevelValueModifier2.Value;
				}
			}
			return dictionary;
		}

		internal static Dictionary<DataObjects.CreatureBaseAttribute, float> DetermineCreatureBaseStats(DataObjects.BiomeSpecificSetting biome_settings, DataObjects.CreatureSpecificSetting creature_settings)
		{
			Dictionary<DataObjects.CreatureBaseAttribute, float> dictionary = new Dictionary<DataObjects.CreatureBaseAttribute, float>
			{
				{
					DataObjects.CreatureBaseAttribute.BaseDamage,
					1f
				},
				{
					DataObjects.CreatureBaseAttribute.BaseHealth,
					1f
				},
				{
					DataObjects.CreatureBaseAttribute.Size,
					1f
				},
				{
					DataObjects.CreatureBaseAttribute.Speed,
					1f
				},
				{
					DataObjects.CreatureBaseAttribute.AttackSpeed,
					1f
				}
			};
			if (biome_settings != null && biome_settings.CreatureBaseValueModifiers != null)
			{
				foreach (KeyValuePair<DataObjects.CreatureBaseAttribute, float> creatureBaseValueModifier in biome_settings.CreatureBaseValueModifiers)
				{
					dictionary[creatureBaseValueModifier.Key] = creatureBaseValueModifier.Value;
				}
			}
			if (creature_settings != null && creature_settings.CreatureBaseValueModifiers != null)
			{
				foreach (KeyValuePair<DataObjects.CreatureBaseAttribute, float> creatureBaseValueModifier2 in creature_settings.CreatureBaseValueModifiers)
				{
					dictionary[creatureBaseValueModifier2.Key] = creatureBaseValueModifier2.Value;
				}
			}
			dictionary[DataObjects.CreatureBaseAttribute.Size] = Mathf.Max(ValConfig.MinimumCreatureScale.Value, dictionary[DataObjects.CreatureBaseAttribute.Size]);
			return dictionary;
		}
	}
	internal static class DamagePatches
	{
		[HarmonyPatch(typeof(Attack), "GetLevelDamageFactor")]
		public static class ModifyDamagePerLevel
		{
			public static bool Prefix(Attack __instance, ref float __result)
			{
				__result = DetermineDamageFactor((Character)(object)__instance.m_character);
				return false;
			}

			private static float DetermineDamageFactor(Character character)
			{
				if (character.IsPlayer())
				{
					return 1f;
				}
				DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(character);
				int num = Mathf.Max(0, character.GetLevel() - 1);
				float num2 = 1f;
				num2 = (character.IsBoss() ? ((andSetLocalCache == null || andSetLocalCache.CreaturePerLevelValueModifiers[DataObjects.CreaturePerLevelAttribute.DamagePerLevel] == 0f) ? (num2 + (float)num * ValConfig.BossEnemyDamageMultiplier.Value) : (num2 + (float)num * andSetLocalCache.CreaturePerLevelValueModifiers[DataObjects.CreaturePerLevelAttribute.DamagePerLevel])) : ((andSetLocalCache == null || andSetLocalCache.CreaturePerLevelValueModifiers[DataObjects.CreaturePerLevelAttribute.DamagePerLevel] == 0f) ? (num2 + (float)num * ValConfig.EnemyDamageLevelMultiplier.Value) : (num2 + (float)num * andSetLocalCache.CreaturePerLevelValueModifiers[DataObjects.CreaturePerLevelAttribute.DamagePerLevel])));
				float num3 = character.m_nview.GetZDO().GetFloat(DataObjects.SLS_DAMAGE_MODIFIER, 1f);
				if (ValConfig.EnableDebugOutputForDamage.Value)
				{
					Logger.LogDebug($"Setting {((Object)character).name} lvl {num} dmg factor to {num2} * {num3} = {num2 * num3}");
				}
				return num2 * num3;
			}
		}

		[HarmonyPatch(typeof(Character), "ApplyDamage")]
		public static class CharacterApplyDamage
		{
			private static void Prefix(HitData hit)
			{
				if (ValConfig.EnableDebugOutputForDamage.Value)
				{
					Logger.LogDebug($"Applying Damage: D:{hit.m_damage.m_damage} fi:{hit.m_damage.m_fire} fr:{hit.m_damage.m_frost} s:{hit.m_damage.m_spirit} po:{hit.m_damage.m_poison} b:{hit.m_damage.m_blunt} p:{hit.m_damage.m_pierce} s:{hit.m_damage.m_slash}");
				}
			}
		}

		[HarmonyPatch(typeof(HitData), "ApplyResistance")]
		public static class ApplyResistance
		{
			private static void Postfix(HitData __instance, DamageModifiers modifiers)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				if (ValConfig.EnableDebugOutputForDamage.Value)
				{
					Logger.LogDebug($"Applying Damage Modifiers {modifiers}, result after modifiers: D:{__instance.m_damage.m_damage} fi:{__instance.m_damage.m_fire} fr:{__instance.m_damage.m_frost} s:{__instance.m_damage.m_spirit} po:{__instance.m_damage.m_poison} b:{__instance.m_damage.m_blunt} p:{__instance.m_damage.m_pierce} s:{__instance.m_damage.m_slash}");
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		public static class CharacterDamageModificationApply
		{
			private static void Prefix(HitData hit, Character __instance)
			{
				DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(hit.GetAttacker());
				DataObjects.CharacterCacheEntry cacheEntry2 = CompositeLazyCache.GetCacheEntry(__instance);
				if (cacheEntry != null && cacheEntry.CreatureDamageBonus != null && cacheEntry.CreatureDamageBonus.Count > 0)
				{
					if (ValConfig.EnableDebugOutputForDamage.Value)
					{
						Logger.LogDebug($"{((Object)__instance).name} Hit:{hit.GetTotalDamageOptions()} Adding {cacheEntry.GetDamageBonusDescription()}");
					}
					DamageModifications.AddDamagesToHit(hit, cacheEntry.CreatureDamageBonus);
				}
				if (cacheEntry2 != null)
				{
					DamageModifications.ApplyDamageModifiers(hit, __instance, cacheEntry2.DamageRecievedModifiers);
				}
			}
		}
	}
}
namespace StarLevelSystem.modules.CreatureSetup
{
	internal static class CreatureSetupControl
	{
		internal static bool RunCharacterSetup(Character __instance, DataObjects.CharacterCacheEntry cDetails)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid() || cDetails == null || cDetails.Level == 0)
			{
				return false;
			}
			cDetails.CreatureNameLocalizable = CreatureModifiers.BuildCreatureLocalizableName(__instance, cDetails.CreatureModifiers);
			CreatureModifiers.RunOnceModifierSetup(__instance, cDetails);
			CreatureModifiers.SetupModifiers(__instance, cDetails, CompositeLazyCache.GetCreatureModifiers(__instance));
			SpeedModifications.ApplySpeedModifications(__instance, cDetails);
			DamageModifications.ApplyDamageModification(__instance, cDetails);
			SizeModifications.SetSizeModification(((Component)__instance).gameObject, __instance.m_nview, cDetails);
			HealthModifications.ApplyHealthModifications(__instance, cDetails);
			UIHudControl.InvalidateCacheEntry(__instance);
			if (__instance.m_level <= 1)
			{
				return true;
			}
			Colorization.ApplyColorizationWithoutLevelEffects(((Component)__instance).gameObject, cDetails.Colorization);
			Colorization.ApplyLevelVisual(__instance);
			return true;
		}

		internal static void CreatureSpawnerSetup(Character chara, int leveloverride = 0, bool multiply = true, float delay = 0.1f, Dictionary<string, DataObjects.ModifierType> requiredModifiers = null, List<string> notAllowedModifiers = null)
		{
			if (!((Object)(object)chara == (Object)null))
			{
				CompositeLazyCache.GetAndSetLocalCache(chara, leveloverride, requiredModifiers, notAllowedModifiers, updateCache: true);
				CreatureSetup(chara, leveloverride, multiply, delay, requiredModifiers, notAllowedModifiers);
			}
		}

		internal static void ApplySpawnAI(MonsterAI ai, DataObjects.AI creatureAI)
		{
			if ((Object)(object)ai == (Object)null)
			{
				return;
			}
			switch (creatureAI)
			{
			case DataObjects.AI.HuntPlayer:
				((BaseAI)ai).SetHuntPlayer(true);
				break;
			case DataObjects.AI.Alerted:
				((BaseAI)ai).SetAlerted(true);
				break;
			case DataObjects.AI.AgitatedByBuild:
				if (((BaseAI)ai).IsAggravatable())
				{
					((BaseAI)ai).SetAggravated(true, (AggravatedReason)1);
					((BaseAI)ai).SetAlerted(true);
				}
				else
				{
					((BaseAI)ai).SetAlerted(true);
					((BaseAI)ai).SetHuntPlayer(true);
				}
				break;
			default:
				((BaseAI)ai).SetAlerted(true);
				break;
			}
		}

		internal static void CreatureSetup(Character __instance, int leveloverride = 0, bool multiply = true, float delay = 1f, Dictionary<string, DataObjects.ModifierType> requiredModifiers = null, List<string> notAllowedModifiers = null)
		{
			if (delay < 0f)
			{
				delay = 0f;
			}
			CreatureSetupQueue.Enqueue(__instance, leveloverride, multiply, delay, requiredModifiers, notAllowedModifiers);
		}
	}
	internal static class CreatureSetupPatches
	{
		[HarmonyPatch(typeof(Character), "Awake")]
		public static class CreatureCharacterExtension
		{
			public static void Postfix(Character __instance)
			{
				ZDO val = (((Object)(object)__instance.m_nview != (Object)null) ? __instance.m_nview.GetZDO() : null);
				if (val != null && val.GetBool(DataObjects.SLS_NEMESIS_BOSS, false))
				{
					__instance.m_boss = true;
					__instance.m_dontHideBossHud = true;
				}
				CreatureSetupControl.CreatureSetup(__instance, 0, multiply: true, ValConfig.InitialDelayBeforeSetup.Value);
			}
		}

		[HarmonyPatch(typeof(Character), "SetLevel")]
		public static class PreventInvalidLeveledCharacters
		{
			public static void Prefix(ref int level)
			{
				if (level <= 1)
				{
					level = 1;
				}
			}
		}
	}
	internal static class CreatureSetupQueue
	{
		private static readonly HashSet<ZDOID> InProgress = new HashSet<ZDOID>();

		internal static bool Enqueue(Character chara, int levelOverride, bool spawnMultiply, float delay, Dictionary<string, DataObjects.ModifierType> requiredModifiers, List<string> notAllowedModifiers)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)chara == (Object)null)
			{
				return false;
			}
			if (chara.IsPlayer())
			{
				return false;
			}
			if ((Object)(object)chara.m_nview == (Object)null || !chara.m_nview.IsValid())
			{
				return false;
			}
			ZDOID zDOID = chara.GetZDOID();
			if (zDOID == ZDOID.None)
			{
				return false;
			}
			if (!InProgress.Add(zDOID))
			{
				return false;
			}
			((MonoBehaviour)TaskRunner.Run()).StartCoroutine(ProcessEntry(chara, zDOID, levelOverride, spawnMultiply, delay, requiredModifiers, notAllowedModifiers));
			return true;
		}

		internal static void RemoveTracking(ZDOID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!(id == ZDOID.None))
			{
				InProgress.Remove(id);
			}
		}

		private static IEnumerator ProcessEntry(Character chara, ZDOID id, int levelOverride, bool spawnMultiply, float delay, Dictionary<string, DataObjects.ModifierType> requiredModifiers, List<string> notAllowedModifiers)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			int maxAttempts = ValConfig.FallbackDelayBeforeCreatureSetup.Value;
			float retryDelay = 1f;
			bool success = false;
			int attempts = 0;
			bool ownershipClaimAttempted = false;
			while (!success && !((Object)(object)chara == (Object)null))
			{
				if ((Object)(object)chara.m_nview == (Object)null || !chara.m_nview.IsValid())
				{
					yield return (object)new WaitForSeconds(retryDelay);
					attempts++;
					if (attempts >= maxAttempts)
					{
						break;
					}
					continue;
				}
				if ((!Compatibility.IsFGNEnabled || !((Object)(object)ZNet.instance != (Object)null) || ZNet.instance.IsServer()) && !ownershipClaimAttempted && !chara.m_nview.m_zdo.Owned)
				{
					chara.m_nview.ClaimOwnership();
					ownershipClaimAttempted = true;
				}
				bool flag = chara.m_nview.IsOwner() || ValConfig.ForceControlAllSpawns.Value;
				DataObjects.CharacterCacheEntry andSetLocalCache;
				if (flag)
				{
					andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara, levelOverride, requiredModifiers, notAllowedModifiers);
					CompositeLazyCache.StartZOwnerCreatureRoutines(chara, andSetLocalCache, spawnMultiply);
				}
				else
				{
					andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(chara, levelOverride, requiredModifiers, notAllowedModifiers);
				}
				success = CreatureSetupControl.RunCharacterSetup(chara, andSetLocalCache);
				if (success)
				{
					continue;
				}
				attempts++;
				if (attempts == maxAttempts - 1)
				{
					DataObjects.CharacterCacheEntry andSetLocalCache2 = CompositeLazyCache.GetAndSetLocalCache(chara, levelOverride, requiredModifiers, notAllowedModifiers, updateCache: true);
					if (flag)
					{
						CompositeLazyCache.StartZOwnerCreatureRoutines(chara, andSetLocalCache2, spawnMultiply);
					}
					success = CreatureSetupControl.RunCharacterSetup(chara, andSetLocalCache2);
					if (success)
					{
						Logger.LogDebug(andSetLocalCache2.RefCreatureName + " running delayed setup.");
					}
				}
				if (attempts >= maxAttempts)
				{
					break;
				}
				if (!success)
				{
					yield return (object)new WaitForSeconds(retryDelay);
				}
			}
			if (id != ZDOID.None)
			{
				InProgress.Remove(id);
			}
		}
	}
}
namespace StarLevelSystem.modules.AnimationAndSpeed
{
	internal static class AnimationSpeedPatches
	{
		[HarmonyPatch(typeof(CharacterAnimEvent), "CustomFixedUpdate")]
		public static class ModifyCharacterAnimationSpeed
		{
			public static void Postfix(CharacterAnimEvent __instance)
			{
				if ((Object)(object)__instance.m_character == (Object)null || !__instance.m_character.InAttack())
				{
					return;
				}
				DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(__instance.m_character);
				if (cacheEntry != null)
				{
					float value;
					float num = (cacheEntry.CreatureBaseValueModifiers.TryGetValue(DataObjects.CreatureBaseAttribute.AttackSpeed, out value) ? value : 1f);
					float value2;
					float num2 = (cacheEntry.CreaturePerLevelValueModifiers.TryGetValue(DataObjects.CreaturePerLevelAttribute.AttackSpeedPerLevel, out value2) ? value2 : 0f);
					if (num != 1f || num2 != 0f)
					{
						__instance.m_animator.speed = num + num2 * (float)__instance.m_character.m_level;
					}
				}
			}
		}
	}
	internal static class SpeedModifications
	{
		internal static void ApplySpeedModifications(Character creature, DataObjects.CharacterCacheEntry cDetails)
		{
			float num = cDetails.CreaturePerLevelValueModifiers[DataObjects.CreaturePerLevelAttribute.SpeedPerLevel];
			float num2 = cDetails.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.Speed];
			float num3 = num * (float)(creature.m_level - 1);
			float num4 = num2 + num3;
			string text = cDetails.RefCreatureName;
			if (text == null)
			{
				text = Utils.GetPrefabName(((Component)creature).gameObject);
			}
			GameObject prefab = PrefabManager.Instance.GetPrefab(text);
			if ((Object)(object)prefab == (Object)null)
			{
				Logger.LogWarning("Unable to find reference object for " + ((Object)creature).name + ", not applying speed modifications");
				return;
			}
			Character component = prefab.GetComponent<Character>();
			if ((Object)(object)component == (Object)null)
			{
				Logger.LogWarning("Unable to find reference character for " + ((Object)creature).name + ", not applying speed modifications");
				return;
			}
			creature.m_speed = component.m_speed * num4;
			creature.m_walkSpeed = component.m_walkSpeed * num4;
			creature.m_runSpeed = component.m_runSpeed * num4;
			creature.m_turnSpeed = component.m_turnSpeed * num4;
			creature.m_flyFastSpeed = component.m_flyFastSpeed * num4;
			creature.m_flySlowSpeed = component.m_flySlowSpeed * num4;
			creature.m_flyTurnSpeed = component.m_flyTurnSpeed * num4;
			creature.m_swimSpeed = component.m_swimSpeed * num4;
			creature.m_crouchSpeed = component.m_crouchSpeed * num4;
		}
	}
}
namespace StarLevelSystem.Modifiers
{
	internal static class Alert
	{
		[UsedImplicitly]
		public static void Setup(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			BaseAI baseAI = creature.m_baseAI;
			baseAI.m_hearRange *= config.BasePower + config.PerlevelPower * (float)creature.m_level;
		}
	}
	internal class Big
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.Size] += config.BasePower + config.PerlevelPower * (float)creature.m_level;
				ccache.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.BaseHealth] += config.BasePower + config.PerlevelPower * (float)creature.m_level;
			}
		}
	}
	internal static class Brutal
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.AttackSpeed] += config.BasePower;
				ccache.CreaturePerLevelValueModifiers[DataObjects.CreaturePerLevelAttribute.AttackSpeedPerLevel] += config.PerlevelPower * (float)creature.m_level;
			}
		}
	}
	internal static class DeathNova
	{
		[HarmonyPatch(typeof(Character), "OnDeath")]
		public static class DeathNovaOnDeathPatch
		{
			private static void Prefix(Character __instance)
			{
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Unknown result type (might be due to invalid IL or missing references)
				//IL_024c: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || __instance.IsPlayer() || !__instance.m_nview.IsOwner())
				{
					return;
				}
				Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(__instance);
				if (creatureModifiers == null)
				{
					return;
				}
				if (Enumerable.Contains(creatureModifiers.Keys, CreatureModifiersData.ModifierNames.FireNova.ToString()))
				{
					DataObjects.CreatureModifierConfiguration modifierDef = CreatureModifiersData.GetModifierDef(CreatureModifiersData.ModifierNames.FireNova.ToString(), creatureModifiers[CreatureModifiersData.ModifierNames.FireNova.ToString()]);
					if (modifierDef == null)
					{
						return;
					}
					GameObject val = CreatureModifiers.ApplySecondaryVFX(CreatureModifiersData.ModifierDefinitions[CreatureModifiersData.ModifierNames.FireNova.ToString()].SecondaryEffect, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
					if ((Object)(object)val == (Object)null)
					{
						return;
					}
					val.SetActive(false);
					Aoe component = val.GetComponent<Aoe>();
					float num = modifierDef.Config.BasePower + modifierDef.Config.PerlevelPower * (float)__instance.m_level;
					if (Object.op_Implicit((Object)(object)component))
					{
						float num2 = SLSExtensions.EstimateCharacterDamage(__instance, DataObjects.DamageEstimateType.Average);
						if (num2 <= 0f)
						{
							num2 = 10 * __instance.m_level;
						}
						component.m_damage.m_blunt = Mathf.Clamp(num2 * num * 0.25f, 0f, 5000f);
						component.m_damage.m_fire = Mathf.Clamp(num2 * num * 0.5f, 0f, 5000f);
						Logger.LogDebug($"Activating FireNova m:{num} x c:{num2} = {num2 * num} | blunt: {component.m_damage.m_blunt} fire: {component.m_damage.m_fire}");
					}
					val.SetActive(true);
				}
				if (!Enumerable.Contains(creatureModifiers.Keys, CreatureModifiersData.ModifierNames.PoisonNova.ToString()))
				{
					return;
				}
				DataObjects.CreatureModifierConfiguration modifierDef2 = CreatureModifiersData.GetModifierDef(CreatureModifiersData.ModifierNames.PoisonNova.ToString(), creatureModifiers[CreatureModifiersData.ModifierNames.PoisonNova.ToString()]);
				if (modifierDef2 == null)
				{
					return;
				}
				GameObject val2 = CreatureModifiers.ApplySecondaryVFX(CreatureModifiersData.ModifierDefinitions[CreatureModifiersData.ModifierNames.PoisonNova.ToString()].SecondaryEffect, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				val2.SetActive(false);
				Aoe component2 = val2.GetComponent<Aoe>();
				float num3 = modifierDef2.Config.BasePower + modifierDef2.Config.PerlevelPower * (float)__instance.m_level;
				if (Object.op_Implicit((Object)(object)component2))
				{
					float num4 = SLSExtensions.EstimateCharacterDamage(__instance, DataObjects.DamageEstimateType.Average);
					if (num4 <= 0f)
					{
						num4 = 10 * __instance.m_level;
					}
					component2.m_damage.m_blunt = Mathf.Clamp(num4 * num3 * 0.16f, 0f, 5000f);
					component2.m_damage.m_poison = Mathf.Clamp(num4 * num3, 0f, 5000f);
					Logger.LogDebug($"Activating Poison Nova m:{num3} x c:{num4} = {num4 * num3}");
				}
				val2.SetActive(true);
			}
		}
	}
	internal static class Drainers
	{
		private enum DrainOutcome
		{
			Clean,
			Dodge,
			Block,
			Parry
		}

		private class DrainContext
		{
			public float BaseDamage;

			public Character Attacker;

			public Dictionary<string, DataObjects.ModifierType> Mods;

			public DrainOutcome Outcome;

			public float PreBlockDamage;
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		public static class ModifierDrain
		{
			private static void Prefix(HitData hit, Character __instance)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				if (hit == null)
				{
					return;
				}
				_ = hit.m_attacker;
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsOwner())
				{
					return;
				}
				Character attacker = hit.GetAttacker();
				if (!((Object)(object)attacker == (Object)null) && !attacker.IsPlayer())
				{
					Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(attacker);
					if (HasDrainMod(creatureModifiers) && !(__instance.GetHealth() <= 0f) && !__instance.IsDead() && !__instance.IsTeleporting() && !__instance.InCutscene())
					{
						DrainContext value = new DrainContext
						{
							Attacker = attacker,
							Mods = creatureModifiers,
							BaseDamage = hit.m_damage.GetTotalDamageOptions(include_poison: true, include_spirit: true),
							Outcome = ((hit.m_dodgeable && __instance.IsDodgeInvincible()) ? DrainOutcome.Dodge : DrainOutcome.Clean)
						};
						_pending.Remove(hit);
						_pending.Add(hit, value);
					}
				}
			}

			private static void Postfix(HitData hit, Character __instance)
			{
				if (hit != null && _pending.TryGetValue(hit, out var value))
				{
					_pending.Remove(hit);
					if (!((Object)(object)value.Attacker == (Object)null) && !((Object)(object)__instance == (Object)null))
					{
						ApplyDrain(__instance, value, "StaminaDrain", stamina: true);
						ApplyDrain(__instance, value, "EitrDrain", stamina: false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "BlockAttack", new Type[]
		{
			typeof(HitData),
			typeof(Character)
		})]
		public static class ModifierDrainBlock
		{
			public static void Prefix(HitData hit, Humanoid __instance)
			{
				if (hit != null && _pending.TryGetValue(hit, out var value) && value.Outcome == DrainOutcome.Clean)
				{
					value.PreBlockDamage = hit.GetTotalBlockableDamage();
				}
			}

			public static void Postfix(HitData hit, Humanoid __instance)
			{
				if (hit != null && !((Object)(object)__instance == (Object)null) && _pending.TryGetValue(hit, out var value) && value.Outcome == DrainOutcome.Clean && hit.GetTotalBlockableDamage() < value.PreBlockDamage - 0.01f)
				{
					ItemData currentBlocker = __instance.GetCurrentBlocker();
					bool flag = currentBlocker != null && currentBlocker.m_shared.m_timedBlockBonus > 1f && __instance.m_blockTimer != -1f && __instance.m_blockTimer < 0.25f;
					value.Outcome = (flag ? DrainOutcome.Parry : DrainOutcome.Block);
				}
			}
		}

		private static readonly ConditionalWeakTable<HitData, DrainContext> _pending = new ConditionalWeakTable<HitData, DrainContext>();

		private const float DefaultBlockReduction = 0.25f;

		private const float DefaultParryReduction = 0.75f;

		private const float DefaultDodgeReduction = 1f;

		private const string StaminaDrainName = "StaminaDrain";

		private const string EitrDrainName = "EitrDrain";

		private static bool HasDrainMod(Dictionary<string, DataObjects.ModifierType> mods)
		{
			if (mods != null)
			{
				if (!mods.ContainsKey("StaminaDrain"))
				{
					return mods.ContainsKey("EitrDrain");
				}
				return true;
			}
			return false;
		}

		private static float ReadConfig(DataObjects.CreatureModConfig cfg, string key, float fallback)
		{
			if (cfg != null && cfg.Config != null && cfg.Config.TryGetValue(key, out var value))
			{
				return value;
			}
			return fallback;
		}

		private static float ReductionFor(DataObjects.CreatureModConfig cfg, DrainOutcome outcome)
		{
			return outcome switch
			{
				DrainOutcome.Parry => ReadConfig(cfg, "ParryReduction", 0.75f), 
				DrainOutcome.Block => ReadConfig(cfg, "BlockReduction", 0.25f), 
				DrainOutcome.Dodge => ReadConfig(cfg, "DodgeReduction", 1f), 
				_ => 0f, 
			};
		}

		private static void ApplyDrain(Character target, DrainContext ctx, string modName, bool stamina)
		{
			if (ctx.Mods.ContainsKey(modName))
			{
				DataObjects.CreatureModConfig config = CreatureModifiersData.GetConfig(modName, ctx.Mods[modName]);
				float num = config.BasePower + config.PerlevelPower * (float)ctx.Attacker.m_level;
				float num2 = ReductionFor(config, ctx.Outcome);
				float num3 = ctx.BaseDamage * num * (1f - num2);
				if (num3 <= 0f)
				{
					Logger.LogDebug($"{modName}: outcome {ctx.Outcome} -> no drain");
				}
				else if (stamina)
				{
					Logger.LogDebug($"Draining Stamina from target {num3} (outcome {ctx.Outcome})");
					target.UseStamina(num3);
				}
				else
				{
					Logger.LogDebug($"Draining Eitr from target {num3} (outcome {ctx.Outcome})");
					target.UseEitr(num3);
				}
			}
		}
	}
	internal static class ElementalChaos
	{
		[HarmonyPriority(700)]
		[HarmonyPatch(typeof(Character), "Damage")]
		public static class ElementalChaosRandomDamageSelectionBonus
		{
			private static readonly List<DataObjects.DamageType> ElementalDamages = new List<DataObjects.DamageType>
			{
				DataObjects.DamageType.Fire,
				DataObjects.DamageType.Frost,
				DataObjects.DamageType.Lightning,
				DataObjects.DamageType.Spirit,
				DataObjects.DamageType.Poison
			};

			private static void Prefix(HitData hit, Character __instance)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				if (hit == null)
				{
					return;
				}
				_ = hit.m_attacker;
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				Character attacker = hit.GetAttacker();
				if (!((Object)(object)attacker == (Object)null) && !attacker.IsPlayer())
				{
					Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(attacker);
					if (creatureModifiers != null && Enumerable.Contains(creatureModifiers.Keys, CreatureModifiersData.ModifierNames.ElementalChaos.ToString()))
					{
						DataObjects.CreatureModConfig config = CreatureModifiersData.GetConfig(CreatureModifiersData.ModifierNames.ElementalChaos.ToString(), creatureModifiers[CreatureModifiersData.ModifierNames.ElementalChaos.ToString()]);
						float num = Mathf.Clamp(config.BasePower + config.PerlevelPower * (float)attacker.m_level, 0f, 500f);
						DataObjects.DamageType damageType = RandomSelectDamageType();
						Logger.LogDebug($"Elemental Chaos adding {damageType} modifier {num}");
						DamageModifications.AddDamagesToHit(hit, new Dictionary<DataObjects.DamageType, float> { { damageType, num } });
					}
				}
			}

			private static DataObjects.DamageType RandomSelectDamageType()
			{
				int index = Random.Range(0, 4);
				return ElementalDamages[index];
			}
		}
	}
	internal static class Evolve
	{
		[HarmonyPatch(typeof(Character), "OnDeath")]
		public static class SoulEaterAndEvolveOnDeath
		{
			private static void Prefix(Character __instance)
			{
				if ((Object)(object)__instance == (Object)null || __instance.IsPlayer() || __instance.m_lastHit == null)
				{
					return;
				}
				Character attacker = __instance.m_lastHit.GetAttacker();
				Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(attacker);
				if (creatureModifiers != null && Enumerable.Contains(creatureModifiers.Keys, CreatureModifiersData.ModifierNames.Evolving.ToString()))
				{
					DataObjects.CreatureModConfig config = CreatureModifiersData.GetConfig(CreatureModifiersData.ModifierNames.Evolving.ToString(), creatureModifiers[CreatureModifiersData.ModifierNames.Evolving.ToString()]);
					int num = attacker.m_nview.GetZDO().GetInt(DataObjects.SLS_EVOLVE, 0);
					num++;
					int level = attacker.m_level;
					int num2 = Mathf.RoundToInt(config.BasePower + config.PerlevelPower * (float)level);
					Logger.LogDebug($"Evolve check: {num} >= {num2}");
					if (num >= num2)
					{
						attacker.m_nview.GetZDO().Set(ZDOVars.s_level, level + 1, false);
						num = 1;
						DataObjects.CharacterCacheEntry andSetLocalCache = CompositeLazyCache.GetAndSetLocalCache(attacker, 0, null, null, updateCache: true);
						SpeedModifications.ApplySpeedModifications(attacker, andSetLocalCache);
						DamageModifications.ApplyDamageModification(attacker, andSetLocalCache);
						SizeModifications.SetSizeModification(((Component)attacker).gameObject, attacker.m_nview, andSetLocalCache, update: true);
						HealthModifications.ForceApplyHealthModifications(attacker, andSetLocalCache);
						attacker.Heal(attacker.GetMaxHealth() * 5f, true);
						Logger.LogDebug($"Evolve: {attacker} level: {level} -> {level + 1}");
					}
					attacker.m_nview.GetZDO().Set(DataObjects.SLS_EVOLVE, num);
				}
			}
		}
	}
	internal class Fast
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.Speed] += config.BasePower + config.PerlevelPower * (float)creature.m_level;
			}
		}
	}
	internal static class Flame
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				if (ccache.CreatureDamageBonus.ContainsKey(DataObjects.DamageType.Fire))
				{
					ccache.CreatureDamageBonus[DataObjects.DamageType.Fire] += config.BasePower + config.PerlevelPower * (float)creature.m_level;
				}
				else
				{
					ccache.CreatureDamageBonus[DataObjects.DamageType.Fire] = config.BasePower + config.PerlevelPower * (float)creature.m_level;
				}
			}
		}
	}
	internal static class Frost
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				if (ccache.CreatureDamageBonus.ContainsKey(DataObjects.DamageType.Frost))
				{
					ccache.CreatureDamageBonus[DataObjects.DamageType.Frost] += config.BasePower + config.PerlevelPower * (float)creature.m_level;
				}
				else
				{
					ccache.CreatureDamageBonus[DataObjects.DamageType.Frost] = config.BasePower + config.PerlevelPower * (float)creature.m_level;
				}
			}
		}
	}
	public static class LifeLink
	{
		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		public static class LifeLinkDamageDistributionPatch
		{
			private static float NextAllowedRedirection;

			public static void Prefix(Character __instance, HitData hit)
			{
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Expected O, but got Unknown
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(__instance);
				if (creatureModifiers == null || !creatureModifiers.ContainsKey(CreatureModifiersData.ModifierNames.LifeLink.ToString()))
				{
					return;
				}
				DataObjects.CreatureModifierConfiguration modifierDef = CreatureModifiersData.GetModifierDef(CreatureModifiersData.ModifierNames.LifeLink.ToString(), creatureModifiers[CreatureModifiersData.ModifierNames.LifeLink.ToString()]);
				float num = 1f - (modifierDef.Config.BasePower + modifierDef.Config.PerlevelPower * (float)__instance.m_level);
				num = Mathf.Clamp(num, 0.1f, 1f);
				HitData val = new HitData
				{
					m_attacker = hit.m_attacker,
					m_damage = hit.m_damage
				};
				if (val.GetTotalDamageOptions() < 20f || Time.realtimeSinceStartup < NextAllowedRedirection)
				{
					return;
				}
				((DamageTypes)(ref val.m_damage)).Modify(num);
				NextAllowedRedirection = Time.realtimeSinceStartup + 1f;
				List<Character> charactersInRange = SLSExtensions.GetCharactersInRange(((Component)__instance).transform.position, 15f);
				bool flag = false;
				foreach (Character item in charactersInRange)
				{
					if (!item.IsPlayer() && !((Object)(object)item == (Object)(object)__instance))
					{
						Logger.LogDebug("Distributing Damage to " + item.m_name);
						item.Damage(val);
						flag = true;
						break;
					}
				}
				if (flag)
				{
					((DamageTypes)(ref hit.m_damage)).Modify(num);
				}
			}
		}
	}
	internal static class Lightning
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				if (ccache.CreatureDamageBonus.ContainsKey(DataObjects.DamageType.Lightning))
				{
					ccache.CreatureDamageBonus[DataObjects.DamageType.Lightning] += config.BasePower + config.PerlevelPower * (float)creature.m_level;
				}
				else
				{
					ccache.CreatureDamageBonus[DataObjects.DamageType.Lightning] = config.BasePower + config.PerlevelPower * (float)creature.m_level;
				}
			}
		}
	}
	internal static class Lootbags
	{
		[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
		public static class CreatureLootMultiplied
		{
			public static void Postfix(CharacterDrop __instance, List<KeyValuePair<GameObject, int>> __result)
			{
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_character == (Object)null || __instance.m_character.IsPlayer())
				{
					return;
				}
				Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(__instance.m_character);
				if (creatureModifiers == null || !creatureModifiers.ContainsKey(CreatureModifiersData.ModifierNames.Lootbags.ToString()))
				{
					return;
				}
				DataObjects.CreatureModConfig config = CreatureModifiersData.GetConfig(CreatureModifiersData.ModifierNames.Lootbags.ToString(), creatureModifiers[CreatureModifiersData.ModifierNames.Lootbags.ToString()]);
				List<DataObjects.LootEntry> list = new List<DataObjects.LootEntry>();
				float num = config.BasePower + config.PerlevelPower * (float)__instance.m_character.m_level;
				foreach (KeyValuePair<GameObject, int> item in __result)
				{
					if (!((Object)(object)item.Key == (Object)null))
					{
						int maxAmountPerDrop = LootPerformanceChanges.CheckItemStackingConfig(item.Key.GetComponent<ItemDrop>(), DataObjects.DropType.Item);
						list.Add(new DataObjects.LootEntry
						{
							Prefab = item.Key,
							Amount = Mathf.RoundToInt((float)item.Value * Random.Range(0.5f, 1f) * num),
							MaxAmountPerDrop = maxAmountPerDrop
						});
					}
				}
				LootPerformanceChanges.DropItemsPreferAsync(((Component)__instance).gameObject.transform.position, list, immediate: true);
			}
		}

		[UsedImplicitly]
		public static void RunOnce(Character _, DataObjects.CreatureModConfig __, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.Speed] += 0.15f;
				ccache.CreatureBaseValueModifiers[DataObjects.CreatureBaseAttribute.BaseHealth] += 0.3f;
			}
		}
	}
	internal static class Poison
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				if (ccache.CreatureDamageBonus.ContainsKey(DataObjects.DamageType.Poison))
				{
					ccache.CreatureDamageBonus[DataObjects.DamageType.Poison] += config.BasePower + config.PerlevelPower * (float)creature.m_level;
				}
				else
				{
					ccache.CreatureDamageBonus[DataObjects.DamageType.Poison] = config.BasePower + config.PerlevelPower * (float)creature.m_level;
				}
			}
		}
	}
	internal static class ResistBlunt
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.DamageRecievedModifiers[DataObjects.DamageType.Blunt] -= config.BasePower + config.PerlevelPower * (float)creature.m_level;
				if (ccache.DamageRecievedModifiers[DataObjects.DamageType.Blunt] < 0.2f)
				{
					ccache.DamageRecievedModifiers[DataObjects.DamageType.Blunt] = 0.2f;
				}
			}
		}
	}
	internal class ResistFire
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.DamageRecievedModifiers[DataObjects.DamageType.Fire] -= config.BasePower + config.PerlevelPower * (float)creature.m_level;
				if (ccache.DamageRecievedModifiers[DataObjects.DamageType.Fire] < 0.2f)
				{
					ccache.DamageRecievedModifiers[DataObjects.DamageType.Fire] = 0.2f;
				}
			}
		}
	}
	internal class ResistFrost
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.DamageRecievedModifiers[DataObjects.DamageType.Frost] -= config.BasePower + config.PerlevelPower * (float)creature.m_level;
				if (ccache.DamageRecievedModifiers[DataObjects.DamageType.Frost] < 0.2f)
				{
					ccache.DamageRecievedModifiers[DataObjects.DamageType.Frost] = 0.2f;
				}
			}
		}
	}
	internal static class ResistPierce
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.DamageRecievedModifiers[DataObjects.DamageType.Pierce] -= config.BasePower + config.PerlevelPower * (float)creature.m_level;
				if (ccache.DamageRecievedModifiers[DataObjects.DamageType.Pierce] < 0.2f)
				{
					ccache.DamageRecievedModifiers[DataObjects.DamageType.Pierce] = 0.2f;
				}
			}
		}
	}
	internal class ResistPoison
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.DamageRecievedModifiers[DataObjects.DamageType.Poison] -= config.BasePower + config.PerlevelPower * (float)creature.m_level;
				if (ccache.DamageRecievedModifiers[DataObjects.DamageType.Poison] < 0.2f)
				{
					ccache.DamageRecievedModifiers[DataObjects.DamageType.Poison] = 0.2f;
				}
			}
		}
	}
	internal static class ResistSlash
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.DamageRecievedModifiers[DataObjects.DamageType.Slash] -= config.BasePower + config.PerlevelPower * (float)creature.m_level;
				if (ccache.DamageRecievedModifiers[DataObjects.DamageType.Slash] < 0.2f)
				{
					ccache.DamageRecievedModifiers[DataObjects.DamageType.Slash] = 0.2f;
				}
			}
		}
	}
	internal class ResistSpirit
	{
		[UsedImplicitly]
		public static void RunOnce(Character creature, DataObjects.CreatureModConfig config, DataObjects.CharacterCacheEntry ccache)
		{
			if (ccache != null)
			{
				ccache.DamageRecievedModifiers[DataObjects.DamageType.Spirit] -= config.BasePower + config.PerlevelPower * (float)creature.m_level;
				if (ccache.DamageRecievedModifiers[DataObjects.DamageType.Spirit] < 0.2f)
				{
					ccache.DamageRecievedModifiers[DataObjects.DamageType.Spirit] = 0.2f;
				}
			}
		}
	}
	internal static class SoulEater
	{
		[HarmonyPatch(typeof(Character), "OnDeath")]
		public static class SoulEaterAndEvolveOnDeath
		{
			private static void Prefix(Character __instance)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || __instance.IsPlayer())
				{
					return;
				}
				foreach (Character item in SLSExtensions.GetCharactersInRange(((Component)__instance).transform.position, 5f))
				{
					if (!((Object)(object)item == (Object)null) && !item.IsPlayer())
					{
						DataObjects.CharacterCacheEntry cacheEntry = CompositeLazyCache.GetCacheEntry(item);
						Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(__instance);
						if (cacheEntry != null && creatureModifiers != null && Enumerable.Contains(creatureModifiers.Keys, CreatureModifiersData.ModifierNames.SoulEater.ToString()))
						{
							DataObjects.CreatureModConfig config = CreatureModifiersData.GetConfig(CreatureModifiersData.ModifierNames.SoulEater.ToString(), creatureModifiers[CreatureModifiersData.ModifierNames.SoulEater.ToString()]);
							float num = config.PerlevelPower * (float)item.m_level;
							Logger.LogDebug($"SoulEater Increased on {((Object)item).name} by {config.PerlevelPower} * {item.m_level} = {num}");
							DamageModifications.ForceUpdateDamageMod(item, num);
							int num2 = item.m_nview.GetZDO().GetInt(DataObjects.SLS_SOULEATER, 0);
							num2++;
							item.m_nview.GetZDO().Set(DataObjects.SLS_SOULEATER, num2);
							SizeModifications.SetSizeModification(((Component)item).gameObject, item.m_nview, cacheEntry, update: true, 0.01f * (float)num2);
							item.Heal(item.GetMaxHealth() * config.PerlevelPower, true);
						}
					}
				}
			}
		}
	}
	public static class Splitter
	{
		[HarmonyPatch(typeof(Character), "OnDeath")]
		public static class CharacterOnDeath
		{
			public static void Prefix(Character __instance)
			{
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || __instance.IsPlayer())
				{
					return;
				}
				Dictionary<string, DataObjects.ModifierType> creatureModifiers = CompositeLazyCache.GetCreatureModifiers(__instance);
				if (creatureModifiers == null || !creatureModifiers.ContainsKey(CreatureModifiersData.ModifierNames.Splitter.ToString()))
				{
					return;
				}
				DataObjects.CreatureModConfig config = CreatureModifiersData.GetConfig(CreatureModifiersData.ModifierNames.Splitter.ToString(), creatureModifiers[CreatureModifiersData.ModifierNames.Splitter.ToString()]);
				float num = config.BasePower + (float)__instance.m_level * config.PerlevelPower;
				bool flag = __instance.IsTamed();
				int num2 = Mathf.RoundToInt((float)__instance.m_level / num);
				if (num2 <= 0)
				{
					num2 = 1;
				}
				if (!ValConfig.SplittersInheritLevel.Value)
				{
					num2 = Random.Range(1, num2);
				}
				Logger.LogDebug($"Splitter on {((Object)__instance).name} total split potential:{num} split creature level: {num2}");
				while (num >= 1f)
				{
					GameObject prefab = PrefabManager.Instance.GetPrefab(Utils.GetPrefabName(((Component)__instance).gameObject));
					if (!((Object)(object)prefab == (Object)null))
					{
						GameObject val = Object.Instantiate<GameObject>(prefab, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
						num -= 1f;
						if (flag)
						{
							val.GetComponent<Character>().SetTamed(true);
						}
						Character component = val.GetComponent<Character>();
						if ((Object)(object)component != (Object)null)
						{
							CompositeLazyCache.GetAndSetLocalCache(component, num2, null, new List<string> { CreatureModifiersData.ModifierNames.Splitter.ToString() }, updateCache: true);
							CreatureSetupControl.CreatureSetup(component, num2, multiply: false, 0.1f);
							CreatureModifiers.RemoveCreatureModifier(component, CreatureModifiersData.ModifierNames.Splitter.ToString());
						}
						continue;
					}
					break;
				}
			}
		}
	}
	internal class Summoner
	{
		public class SLSSummoner : MonoBehaviour
		{
			private List<GameObject> summonableCreatures = new List<GameObject>();

			private ZNetView creature_znet;

			private static List<ZDOID> spawned = new List<ZDOID>();

			private static int maxSummoned = 10;

			private static int summonBatchSize = 2;

			private static float timeBetweenSummons = 30f;

			private static Character bossCharacter;

			private static bool started = false;

			public void SpawnCreaturesBatch()
			{
				summonBatchSize.Times(delegate
				{
					SpawnCreatureRandomly();
				});
			}

			public void SpawnCreatureRandomly()
			{
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				if (summonableCreatures.Count == 0)
				{
					return;
				}
				if (spawned.Count >= maxSummoned)
				{
					spawned.RemoveAll((ZDOID x) => ZDOMan.instance.GetZDO(x) == null);
					if (spawned.Count >= maxSummoned)
					{
						return;
					}
				}
				if (summonableCreatures.Count != 0 && !((Object)(object)bossCharacter == (Object)null))
				{
					GameObject obj = summonableCreatures[Random.Range(0, summonableCreatures.Count)];
					Vector3 val = ((Component)bossCharacter).transform.position + new Vector3((float)Random.Range(-10, 10), 0f, (float)Random.Range(-10, 10));
					val.y = ZoneSystem.instance.GetGroundHeight(val) + 0.5f;
					Character component = Object.Instantiate<GameObject>(obj, val, Quaternion.identity).GetComponent<Character>();
					if ((Object)(object)component != (Object)null)
					{
						spawned.Add(component.GetZDOID());
					}
				}
			}

			public void SetupSummoner(Character character, List<string> summonPrefabs, int max_summoned = 10, float time_between_summons = 60f)
			{
				bossCharacter = character;
				timeBetweenSummons = time_between_summons;
				maxSummoned = max_summoned;
				creature_znet = character.m_nview;
				foreach (string summonPrefab in summonPrefabs)
				{
					GameObject prefab = PrefabManager.Instance.GetPrefab(summonPrefab);
					if ((Object)(object)prefab != (Object)null)
					{
						summonableCreatures.Add(prefab);
					}
				}
				if ((Object)(object)creature_znet == (Object)null)
				{
					creature_znet = ((Component)this).gameObject.GetComponent<ZNetView>();
				}
				if (!started)
				{
					((MonoBehaviour)this).InvokeRepeating("SpawnCreaturesBatch", timeBetweenSummons, timeBetweenSummons);
					started = true;
				}
			}
		}

		public static void Setup(Character creature = null, DataObjects.CreatureModConfig config = null, DataObjects.CharacterCacheEntry ccache = null)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (ccache == null)
			{
				return;
			}
			SLSSummoner component = ((Component)creature).GetComponent<SLSSummoner>();
			Logger.LogDebug($"Setting up Summoner for {((Object)creature).name} summon script {component}");
			if ((Object)(object)component == (Object)null)
			{
				SLSSummoner sLSSummoner = ((Component)creature).gameObject.AddComponent<SLSSummoner>();
				if (config.BiomeObjects.ContainsKey(ccache.Biome))
				{
					sLSSummoner.SetupSummoner(creature, config.BiomeObjects[ccache.Biome], Mathf.RoundToInt(config.BasePower), config.PerlevelPower);
				}
			}
		}
	}
}
namespace StarLevelSystem.Data
{
	public static class ColorizationData
	{
		internal static readonly Dictionary<string, Dictionary<int, DataObjects.ColorDef>> characterColorizationData = new Dictionary<string, Dictionary<int, DataObjects.ColorDef>>
		{
			{
				"Deer",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.05f,
							Saturation = -0.1f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0.09f,
							Saturation = -0.5f,
							Value = -0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.07f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.09f,
							Saturation = 0f,
							Value = -0.09f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.11f,
							Saturation = 0f,
							Value = -0.11f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.5f,
							Value = -0.15f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.5f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.5f,
							Value = -0.08f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.3f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.5f,
							Value = 0f
						}
					}
				}
			},
			{
				"Boar",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.05f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.07f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.09f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0f,
							Value = -0.05f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0f,
							Value = -0.05f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.05f,
							Saturation = 0f,
							Value = 0.05f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.05f,
							Saturation = 0.1f,
							Value = 0.05f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.1f,
							Value = -0.05f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.02f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.05f,
							Value = -0.1f
						}
					}
				}
			},
			{
				"Neck",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.07f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0.05f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0f,
							Value = -0.05f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.4f,
							Saturation = 0f,
							Value = -0.05f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.25f,
							Saturation = 0f,
							Value = -0.05f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0f,
							Value = -0.15f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0f,
							Value = -0.2f
						}
					}
				}
			},
			{
				"Greyling",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.06f,
							Saturation = 0.1f,
							Value = 0.05f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = -0.01f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.2f,
							Value = -0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0.2f,
							Value = -0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.7f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.2f,
							Value = -0.07f
						}
					}
				}
			},
			{
				"Eikthyr",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.5f,
							Saturation = 0f,
							Value = -0.05f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.75f,
							Saturation = 0f,
							Value = -0.15f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0f,
							Value = 0.05f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.2f,
							Saturation = 0f,
							Value = 0.5f
						}
					}
				}
			},
			{
				"Greydwarf",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.06f,
							Saturation = 0.1f,
							Value = 0.05f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = -0.01f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.2f,
							Value = -0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0.2f,
							Value = -0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.7f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.2f,
							Value = -0.07f
						}
					}
				}
			},
			{
				"Greydwarf_Shaman",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0.3f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.3f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.2f,
							Value = -0.07f
						}
					}
				}
			},
			{
				"Greydwarf_Elite",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.046f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.108f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.3f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.2f,
							Value = -0.07f
						}
					}
				}
			},
			{
				"Skeleton",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.03f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Skeleton_NoArcher",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.03f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Skeleton_Poison",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.16f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Troll",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.1f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.2f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0.3f,
							Value = -0.05f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.4f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.5f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.85f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.5f,
							Value = 0f
						}
					}
				}
			},
			{
				"Bjorn",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 5f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.2f,
							Saturation = 0.3f,
							Value = -0.12f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.08f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.05f,
							Saturation = 0.3f,
							Value = -0.12f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.5f,
							Value = -0.05f
						}
					}
				}
			},
			{
				"Serpent",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.05f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.3f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.2f,
							Value = -0.07f
						}
					}
				}
			},
			{
				"Skeleton_Hildir",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.16f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Skeleton_Hildir_nochest",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.16f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"gd_king",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.22f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.33f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.44f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.55f,
							Saturation = 0.3f,
							Value = 0.05f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.66f,
							Saturation = 0f,
							Value = 0.07f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.66f,
							Saturation = -0.15f,
							Value = 0.1f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.66f,
							Saturation = -0.45f,
							Value = 0.1f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -0.88f,
							Saturation = 0f,
							Value = 0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Draugr",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.27f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.25f,
							Saturation = 0.04f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0.32f,
							Saturation = 0.3f,
							Value = 0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.6f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.9f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.2f,
							Value = 0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					}
				}
			},
			{
				"Draugr_Ranged",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.27f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.25f,
							Saturation = 0.04f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0.32f,
							Saturation = 0.3f,
							Value = 0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.6f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.9f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.2f,
							Value = 0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					}
				}
			},
			{
				"Draugr_Elite",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0.32f,
							Saturation = 0.3f,
							Value = 0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.6f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.9f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.2f,
							Value = 0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					}
				}
			},
			{
				"Abomination",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0.32f,
							Saturation = 0.3f,
							Value = 0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.6f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.9f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.2f,
							Value = 0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					}
				}
			},
			{
				"Surtling",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.16f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0.5f,
							Value = -1f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -2f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -3f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -4f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -5f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.5f,
							Value = -5f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.5f,
							Value = -5f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.8f,
							Value = -5f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 1f,
							Value = -5f
						}
					}
				}
			},
			{
				"Leech",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.23f,
							Saturation = 0.26f,
							Value = 0.04f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.139f,
							Saturation = 0.47f,
							Value = 0.06f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0.32f,
							Saturation = 0.3f,
							Value = 0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.6f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.9f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.2f,
							Value = 0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					}
				}
			},
			{
				"Blob",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.23f,
							Saturation = 0.26f,
							Value = 0.04f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.139f,
							Saturation = 0.47f,
							Value = 0.06f
						}
					}
				}
			},
			{
				"BlobElite",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.23f,
							Saturation = 0.26f,
							Value = 0.04f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.139f,
							Saturation = 0.47f,
							Value = 0.06f
						}
					}
				}
			},
			{
				"Bonemass",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = 0f
						}
					}
				}
			},
			{
				"Wolf",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.2f,
							Value = -0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0.2f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.2f,
							Saturation = 0.1f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.4f,
							Saturation = 0.2f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.4f,
							Saturation = 0.3f,
							Value = -0.05f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = -0.5f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -0.9f,
							Saturation = 0.2f,
							Value = -0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Ulv",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.2f,
							Value = -0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0.2f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.2f,
							Saturation = 0.1f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.4f,
							Saturation = 0.2f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.4f,
							Saturation = 0.3f,
							Value = -0.05f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = -0.5f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -0.9f,
							Saturation = 0.2f,
							Value = -0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Fenring",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.2f,
							Value = -0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0.2f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.2f,
							Saturation = 0.1f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.4f,
							Saturation = 0.2f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.4f,
							Saturation = 0.3f,
							Value = -0.05f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = -0.5f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -0.9f,
							Saturation = 0.2f,
							Value = -0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Fenring_Cultist",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.2f,
							Value = -0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0.32f,
							Saturation = 0.3f,
							Value = 0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.6f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.9f,
							Saturation = -0.2f,
							Value = 0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.2f,
							Value = 0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.5f,
							Value = 0.01f
						}
					}
				}
			},
			{
				"Hatchling",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.2f,
							Value = -0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"StoneGolem",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.2f,
							Value = -0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Dragon",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.2f,
							Value = -0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 1f,
							Saturation = 0.3f,
							Value = 0.05f
						}
					}
				}
			},
			{
				"Deathsquito",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.05f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.15f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Lox",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.05f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.5f,
							Value = 0f
						}
					}
				}
			},
			{
				"GoblinArcher",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.05f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.08f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.15f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.22f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.24f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -0.26f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -0.28f,
							Saturation = 0f,
							Value = 0f
						}
					}
				}
			},
			{
				"Goblin",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.05f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.08f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.15f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.22f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.24f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -0.26f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -0.28f,
							Saturation = 0f,
							Value = 0f
						}
					}
				}
			},
			{
				"GoblinBrute",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = -0.1f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0.3f,
							Value = -0.15f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"GoblinShaman",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = -0.1f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0.3f,
							Value = -0.15f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"GoblinBrute_Hildir",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = -0.1f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0.3f,
							Value = -0.15f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"GoblinBruteBros",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = -0.1f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0.3f,
							Value = -0.15f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"GoblinKing",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = 0f
						}
					}
				}
			},
			{
				"Hen",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.05f,
							Saturation = -0.1f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0.09f,
							Saturation = -0.5f,
							Value = -0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Gjall",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.201f,
							Saturation = 0.29f,
							Value = -0.42f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.103f,
							Saturation = -0.08f,
							Value = -0.42f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Tick",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.337f,
							Saturation = -0.09f,
							Value = -0.41f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.027f,
							Saturation = 0.29f,
							Value = -0.41f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Seeker",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.28f,
							Saturation = -0.3f,
							Value = -0.1f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.1f,
							Value = -0.2f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"SeekerBrute",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.5f,
							Saturation = 0.05f,
							Value = -0.08f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.351f,
							Saturation = -0.04f,
							Value = -0.1f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"DvergerMageIce",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.2f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -1f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"DvergerMageSupport",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.2f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -1f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"DvergerMageFire",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.2f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -1f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"DvergerMage",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.2f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -1f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Dverger",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.2f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -1f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.07f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.14f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.18f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.35f,
							Saturation = 0f,
							Value = 0f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"Skeleton_Friendly",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.03f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.15f,
							Saturation = 0.3f,
							Value = -0.151f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.18f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"SeekerQueen",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.03f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.15f,
							Saturation = 0.3f,
							Value = -0.151f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.18f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"BonemawSerpent",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.05f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.3f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.2f,
							Value = -0.07f
						}
					}
				}
			},
			{
				"Asksvin",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.477f,
							Saturation = -1f,
							Value = 0.02f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0.5f,
							Saturation = -0.08f,
							Value = 0.08f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.3f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.2f,
							Value = -0.07f
						}
					}
				}
			},
			{
				"Asksvin_hatchling",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.477f,
							Saturation = -1f,
							Value = 0.02f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0.5f,
							Saturation = -0.08f,
							Value = 0.08f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0.2f,
							Value = -0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0.4f,
							Value = -0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0.6f,
							Value = -0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.3f,
							Saturation = 0.8f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = -0.1f,
							Value = -0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = -0.3f,
							Value = -0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = -0.4f,
							Value = -0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = -0.8f,
							Value = -0.07f
						}
					}
				}
			},
			{
				"Volture",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.477f,
							Saturation = -1f,
							Value = 0.02f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0.5f,
							Saturation = -0.08f,
							Value = 0.08f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.2f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = -0.4f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = -0.5f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.3f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = -0.8f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0f,
							Value = -0.01f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.2f,
							Value = -0.07f
						}
					}
				}
			},
			{
				"FallenValkyrie",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.5f,
							Saturation = 0.2f,
							Value = 0.1f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.3f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Charred_Melee",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.5f,
							Value = 0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Charred_Twitcher",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.5f,
							Value = 0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Charred_Archer",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.5f,
							Value = 0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Charred_Mage",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.5f,
							Value = 0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"DvergerAshlands",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.2f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -1f,
							Value = 0f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.5f,
							Value = 0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Morgen",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = -0.03f,
							Saturation = 0.3f,
							Value = 0f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = -0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = -0.12f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0.01f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0.15f,
							Saturation = 0.3f,
							Value = -0.1f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.5f,
							Value = -0.1f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.05f,
							Saturation = 0.5f,
							Value = -0.1f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.1f,
							Saturation = 0.1f,
							Value = -0.09f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = -1f,
							Saturation = 0.4f,
							Value = -0.25f
						}
					}
				}
			},
			{
				"BlobLava",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.5f,
							Value = 0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Troll_Summoned",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.5f,
							Value = 0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Charred_Twitcher_Summoned",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.5f,
							Value = 0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Charred_Melee_Dyrnwyn",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0.6f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.5f,
							Value = 0.3f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.9f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Charred_Melee_Fader",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.05f,
							Saturation = 0.2f,
							Value = 0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.5f,
							Value = 0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Charred_Archer_Fader",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = 0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.05f,
							Saturation = 0.2f,
							Value = 0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.5f,
							Value = 0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.5f,
							Value = 0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.3f,
							Value = -0.4f
						}
					}
				}
			},
			{
				"Fader",
				new Dictionary<int, DataObjects.ColorDef>
				{
					{
						1,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.1f,
							Value = -0.03f
						}
					},
					{
						2,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.05f
						}
					},
					{
						3,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.1f
						}
					},
					{
						4,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = 0.15f
						}
					},
					{
						5,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = -0.1f,
							Value = -0.25f
						}
					},
					{
						6,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.2f,
							Value = -0.25f
						}
					},
					{
						7,
						new DataObjects.ColorDef
						{
							Hue = 0.05f,
							Saturation = 0.2f,
							Value = -0.2f
						}
					},
					{
						8,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.3f,
							Value = -0.25f
						}
					},
					{
						9,
						new DataObjects.ColorDef
						{
							Hue = 0f,
							Saturation = 0.4f,
							Value = -0.2f
						}
					},
					{
						10,
						new DataObjects.ColorDef
						{
							Hue = 0.45f,
							Saturation = 0.1f,
							Value = -0.4f
						}
					}
				}
			}
		};

		internal static readonly Dictionary<int, DataObjects.ColorDef> defaultColorizationData = new Dictionary<int, DataObjects.ColorDef>
		{
			{
				1,
				new DataObjects.ColorDef
				{
					Hue = 0.07130837f,
					Saturation = 0.2f,
					Value = 0.130073f
				}
			},
			{
				2,
				new DataObjects.ColorDef
				{
					Hue = -0.07488244f,
					Saturation = 0.4406867f,
					Value = 0.01721987f
				}
			},
			{
				3,
				new DataObjects.ColorDef
				{
					Hue = -0.04446793f,
					Saturation = 0.05205864f,
					Value = -0.191282f
				}
			},
			{
				4,
				new DataObjects.ColorDef
				{
					Hue = 0.08774569f,
					Saturation = -0.3959962f,
					Value = 0.224104f
				}
			},
			{
				5,
				new DataObjects.ColorDef
				{
					Hue = -0.05712423f,
					Saturation = 0.09905273f,
					Value = -0.1369882f
				}
			},
			{
				6,
				new DataObjects.ColorDef
				{
					Hue = 0.08566696f,
					Saturation = -0.3398137f,
					Value = -0.2270744f
				}
			},
			{
				7,
				new DataObjects.ColorDef
				{
					Hue = 0.03924248f,
					Saturation = -0.04047304f,
					Value = -0.1966226f
				}
			},
			{
				8,
				new DataObjects.ColorDef
				{
					Hue = -0.3575756f,
					Saturation = 0.09342755f,
					Value = 0.3008582f
				}
			},
			{
				9,
				new DataObjects.ColorDef
				{
					Hue = 0.3575756f,
					Saturation = 0.09342755f,
					Value = -0.1008582f
				}
			},
			{
				10,
				new DataObjects.ColorDef
				{
					Hue = 0f,
					Saturation = -0.25f,
					Value = 0f
				}
			}
		};

		internal static readonly Dictionary<string, List<DataObjects.ColorRangeDef>> defaultColorGenerators = new Dictionary<string, List<DataObjects.ColorRangeDef>> { 
		{
			"DefaultGenerator",
			new List<DataObjects.ColorRangeDef>
			{
				new DataObjects.ColorRangeDef
				{
					CharacterSpecific = false,
					RangeStart = 1,
					RangeEnd = 15,
					StartColorDef = new DataObjects.ColorDef
					{
						Hue = 0.07130837f,
						Saturation = 0.05205864f,
						Value = 0.01721987f
					},
					EndColorDef = new DataObjects.ColorDef
					{
						Hue = -0.07488244f,
						Saturation = 0.09342755f,
						Value = -0.1008582f
					}
				},
				new DataObjects.ColorRangeDef
				{
					CharacterSpecific = false,
					RangeStart = 16,
					RangeEnd = 32,
					StartColorDef = new DataObjects.ColorDef
					{
						Hue = 0f,
						Saturation = -0.3959962f,
						Value = 0f
					},
					EndColorDef = new DataObjects.ColorDef
					{
						Hue = -0.3575756f,
						Saturation = 0.2f,
						Value = -0.2270744f
					}
				}
			}
		} };
	}
	internal static class CompositeLazyCache
	{
		[HarmonyPatch(typeof(ZNetScene), "Destroy")]
		public static class CleanupDeletedCreatures
		{
			private static void Prefix(ZNetScene __instance, GameObject go)
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				ZNetView component = go.GetComponent<ZNetView>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)__instance == (Object)null) && component.GetZDO() != null)
				{
					ZDOID uid = component.GetZDO().m_uid;
					if (SessionCache.ContainsKey(uid))
					{
						SessionCache.Remove(uid);
					}
					CreatureSetupQueue.RemoveTracking(uid);
					RemoveTreeCacheEntry(uid);
					UIHudControl.RemoveExtendedHudFromCache(uid);
				}
			}
		}

		public static readonly Vector2 Center = new Vector2(0f, 0f);

		private static Dictionary<ZDOID, DataObjects.CharacterCacheEntry> SessionCache = new Dictionary<ZDOID, DataObjects.CharacterCacheEntry>();

		private static Dictionary<ZDOID, int> TreeSessionCache = new Dictionary<ZDOID, int>();

		public static int GetOrAddCachedTreeEntry(ZNetView zgo)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)zgo == (Object)null || !zgo.IsValid() || zgo.GetZDO() == null)
			{
				return 1;
			}
			ZDOID uid = zgo.GetZDO().m_uid;
			if (TreeSessionCache.ContainsKey(uid))
			{
				return TreeSessionCache[uid];
			}
			int num = LevelSelection.DeterministicDetermineTreeLevel(((Component)zgo).gameObject);
			TreeSessionCache.Add(uid, num);
			return num;
		}

		public static void RemoveTreeCacheEntry(ZDOID id)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (TreeSessionCache.ContainsKey(id))
			{
				TreeSessionCache.Remove(id);
			}
		}

		internal static void FlushCache()
		{
			Logger.LogDebug("Flushing creature cache...");
			SessionCache.Clear();
		}

		public static bool IsZOwner(Character character)
		{
			if ((Object)(object)character == (Object)null || (Object)(object)character.m_nview == (Object)null)
			{
				return false;
			}
			return character.m_nview.IsOwner();
		}

		public static DataObjects.CharacterCacheEntry GetCacheEntry(ZDOID cid)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (SessionCache.ContainsKey(cid))
			{
				return SessionCache[cid];
			}
			return null;
		}

		public static DataObjects.CharacterCacheEntry GetCacheEntry(Character character)
		{
			return RetrieveStoredCreatureFromCache(character);
		}

		public static void ClearCachedCreature(Character character)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)character == (Object)null) && !((Object)(object)character.m_nview == (Object)null) && !character.IsPlayer() && character.m_nview.GetZDO() != null)
			{
				ZDOID zDOID = character.GetZDOID();
				SessionCache.Remove(zDOID);
			}
		}

		public static DataObjects.CharacterCacheEntry GetAndSetLocalCache(Character character, int leveloverride = 0, Dictionary<string, DataObjects.ModifierType> requiredModifiers = null, List<string> notAllowedModifiers = null, bool updateCache = false)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			DataObjects.CharacterCacheEntry characterCacheEntry = RetrieveStoredCreatureFromCache(character);
			if (characterCacheEntry != null && !updateCache)
			{
				return characterCacheEntry;
			}
			DataObjects.CharacterCacheEntry characterCacheEntry2 = new DataObjects.CharacterCacheEntry();
			characterCacheEntry2.ZDO = character.m_nview.GetZDO();
			LevelSelection.SelectCreatureBiomeSettings(((Component)character).gameObject, out var creature_name, out var creature_settings, out var biome_settings, out var creature_biome);
			characterCacheEntry2.CreatureSettings = creature_settings;
			characterCacheEntry2.Biome = creature_biome;
			characterCacheEntry2.RefCreatureName = creature_name;
			DetermineCreatureSpawnRate(characterCacheEntry2, biome_settings, creature_settings);
			if (requiredModifiers == null)
			{
				if (creature_settings != null && creature_settings.RequiredModifiers != null)
				{
					requiredModifiers = creature_settings.RequiredModifiers;
				}
			}
			else if (creature_settings != null && creature_settings.RequiredModifiers != null)
			{
				foreach (KeyValuePair<string, DataObjects.ModifierType> requiredModifier in creature_settings.RequiredModifiers)
				{
					if (!requiredModifiers.ContainsKey(requiredModifier.Key))
					{
						requiredModifiers.Add(requiredModifier.Key, requiredModifier.Value);
					}
				}
			}
			characterCacheEntry2.ModifiersNotAllowed = notAllowedModifiers;
			characterCacheEntry2.ModifiersRequired = requiredModifiers;
			characterCacheEntry2.CreatureModifiers = GetCreatureModifiers(character);
			bool flag = IsZOwner(character);
			characterCacheEntry2.Level = LevelSelection.DetermineLevel(character, characterCacheEntry2.ZDO, creature_settings, biome_settings, creature_biome, leveloverride, flag);
			characterCacheEntry2.CreatureNameLocalizable = CreatureModifiers.BuildCreatureLocalizableName(character, characterCacheEntry2.CreatureModifiers);
			if (!flag && characterCacheEntry2.Level > 0 && character.m_level != characterCacheEntry2.Level)
			{
				character.m_level = characterCacheEntry2.Level;
				character.SetupMaxHealth();
			}
			characterCacheEntry2.Colorization = Colorization.DetermineCharacterColorization(character, characterCacheEntry2.Level);
			characterCacheEntry2.DamageRecievedModifiers = DamageModifications.DetermineCreatureDamageRecievedModifiers(biome_settings, creature_settings);
			characterCacheEntry2.CreaturePerLevelValueModifiers = DamageModifications.DetermineCharacterPerLevelStats(biome_settings, creature_settings);
			characterCacheEntry2.CreatureBaseValueModifiers = DamageModifications.DetermineCreatureBaseStats(biome_settings, creature_settings);
			ZDOID zDOID = character.GetZDOID();
			if (characterCacheEntry2.Level <= 0)
			{
				return characterCacheEntry2;
			}
			if (SessionCache.ContainsKey(zDOID))
			{
				if (updateCache)
				{
					SessionCache[zDOID] = characterCacheEntry2;
				}
			}
			else
			{
				SessionCache.Add(zDOID, characterCacheEntry2);
			}
			return characterCacheEntry2;
		}

		public static void StartZOwnerCreatureRoutines(Character chara, DataObjects.CharacterCacheEntry characterEntry, bool spawnratecheck = true)
		{
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			if (characterEntry == null || (Object)(object)chara == (Object)null || !IsZOwner(chara))
			{
				return;
			}
			if (characterEntry.Level == 0)
			{
				characterEntry.Level = 1;
			}
			if (characterEntry.ShouldDelete && !chara.m_tamed)
			{
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(Spawnrate.DestroyCoroutine(((Component)chara).gameObject));
				return;
			}
			int level = chara.GetLevel();
			int num = chara.m_nview.GetZDO().GetInt(ZDOVars.s_level, 0);
			if (level <= 1 && (num <= 0 || characterEntry.Level != level))
			{
				chara.m_nview.GetZDO().Set(ZDOVars.s_level, characterEntry.Level, false);
				chara.m_level = characterEntry.Level;
				UIHudControl.InvalidateCacheEntry(chara);
			}
			int maxCreatureLevel = LevelSelection.GetMaxCreatureLevel(chara, characterEntry.CreatureSettings);
			if (ValConfig.OverLevelCreaturesGetRerolledOnLoad.Value && level > maxCreatureLevel)
			{
				characterEntry = GetAndSetLocalCache(chara, 0, null, null, updateCache: true);
				Logger.LogDebug($"{characterEntry.RefCreatureName} level {level} over max {maxCreatureLevel}, resetting to {maxCreatureLevel}");
				chara.m_nview.GetZDO().Set(ZDOVars.s_level, maxCreatureLevel, false);
				chara.m_level = maxCreatureLevel;
				SizeModifications.SetSizeModification(((Component)chara).gameObject, chara.m_nview, characterEntry);
				Colorization.ApplyColorizationWithoutLevelEffects(((Component)chara).gameObject, characterEntry.Colorization);
				UIHudControl.InvalidateCacheEntry(chara);
			}
			if (chara.IsBoss() && ValConfig.ControlBossSpawns.Value)
			{
				chara.m_nview.GetZDO().Set(ZDOVars.s_level, characterEntry.Level, false);
			}
			if (characterEntry.CreatureModifiers == null || characterEntry.CreatureModifiers.Count == 0)
			{
				Dictionary<string, DataObjects.ModifierType> creatureModifiers = GetCreatureModifiers(chara);
				if (creatureModifiers != null && creatureModifiers.Count > 0)
				{
					characterEntry.CreatureModifiers = creatureModifiers;
					UpdateCharacterCacheEntry(chara, characterEntry);
				}
				else
				{
					characterEntry.CreatureModifiers = CreatureModifiers.SelectModifiersForCreature(chara, characterEntry.RefCreatureName, characterEntry.CreatureSettings, characterEntry.Biome, characterEntry.Level, characterEntry.ModifiersRequired, characterEntry.ModifiersNotAllowed);
					SetCreatureModifiers(chara, characterEntry.CreatureModifiers);
				}
			}
			if (!spawnratecheck)
			{
				characterEntry.ZDO.Set(DataObjects.SLS_SPAWN_MULT, true);
			}
			else
			{
				Spawnrate.CheckSetApplySpawnrate(chara, characterEntry);
			}
		}

		public static DataObjects.CharacterCacheEntry RetrieveStoredCreatureFromCache(Character character)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || character.GetZDOID() == ZDOID.None || character.IsPlayer())
			{
				return null;
			}
			ZDOID zDOID = character.GetZDOID();
			if (SessionCache.ContainsKey(zDOID))
			{
				return SessionCache[zDOID];
			}
			return null;
		}

		public static void UpdateCharacterCacheEntry(Character character, DataObjects.CharacterCacheEntry scd)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			ZDOID zDOID = character.GetZDOID();
			if (SessionCache.ContainsKey(zDOID))
			{
				SessionCache[zDOID] = scd;
			}
			else
			{
				SessionCache.Add(zDOID, scd);
			}
		}

		public static Dictionary<string, DataObjects.ModifierType> GetCreatureModifiers(Character character)
		{
			if ((Object)(object)character == (Object)null || (Object)(object)character.m_nview == (Object)null)
			{
				return null;
			}
			string text = character.m_nview.GetZDO().GetString(DataObjects.SLS_MODSV2, (string)null);
			if (text != null)
			{
				try
				{
					return DataObjects.yamlDeserializer.Deserialize<Dictionary<string, DataObjects.ModifierType>>(text);
				}
				catch
				{
					return null;
				}
			}
			return new DataObjects.CreatureModifiersZNetProperty(DataObjects.SLS_MODIFIERS, character.m_nview, null).Get();
		}

		public static void SetCreatureModifiers(Character chara, Dictionary<string, DataObjects.ModifierType> modifiers)
		{
			chara.m_nview.GetZDO().Set(DataObjects.SLS_MODSV2, DataObjects.yamlSerializerJsonCompat.Serialize((object)modifiers));
			DataObjects.CharacterCacheEntry cacheEntry = GetCacheEntry(chara);
			if (cacheEntry != null)
			{
				cacheEntry.CreatureModifiers = modifiers;
				UpdateCharacterCacheEntry(chara, cacheEntry);
			}
		}

		private static void DetermineCreatureSpawnRate(DataObjects.CharacterCacheEntry characterEntry, DataObjects.BiomeSpecificSetting biomeSettings, DataObjects.CreatureSpecificSetting creatureSettings)
		{
			bool flag = EnvMan.IsNight();
			if (biomeSettings != null && biomeSettings.CreatureSpawnsDisabled != null && biomeSettings.CreatureSpawnsDisabled.Contains(characterEntry.RefCreatureName))
			{
				characterEntry.ShouldDelete = true;
				return;
			}
			if (biomeSettings != null)
			{
				float spawnRateModifier = biomeSettings.SpawnRateModifier;
				if (flag && biomeSettings.NightSettings != null && biomeSettings.NightSettings.SpawnRateModifier != 1f)
				{
					spawnRateModifier = biomeSettings.NightSettings.SpawnRateModifier;
				}
				characterEntry.SpawnRateModifier = spawnRateModifier;
			}
			if (creatureSettings != null)
			{
				if (creatureSettings.SpawnRateModifier != 1f)
				{
					characterEntry.SpawnRateModifier = creatureSettings.SpawnRateModifier;
				}
				if (flag && creatureSettings.NightSettings != null && creatureSettings.NightSettings.SpawnRateModifier != 1f)
				{
					characterEntry.SpawnRateModifier = creatureSettings.NightSettings.SpawnRateModifier;
				}
			}
			if (flag)
			{
				if (biomeSettings != null && biomeSettings.NightSettings != null && biomeSettings.NightSettings.CreatureSpawnsDisabled != null && biomeSettings.NightSettings.CreatureSpawnsDisabled.Contains(characterEntry.RefCreatureName))
				{
					characterEntry.ShouldDelete = true;
				}
				else if (creatureSettings != null && creatureSettings.NightSettings != null && creatureSettings.NightSettings.CreatureSpawnsDisabled)
				{
					characterEntry.ShouldDelete = true;
				}
			}
		}
	}
	public static class CreatureModifiersData
	{
		public enum ModifierNames
		{
			None = 0,
			BossSummoner = 1,
			SoulEater = 2,
			LifeLink = 3,
			Splitter = 9,
			Lootbags = 10,
			Fire = 11,
			Frost = 12,
			Poison = 13,
			Lightning = 14,
			FireNova = 15,
			FrostNova = 16,
			PoisonNova = 17,
			LightningNova = 18,
			Evolving = 19,
			ResistSlash = 21,
			ResistBlunt = 22,
			ResistPierce = 23,
			ResistFire = 24,
			ResistFrost = 25,
			ResistPoison = 26,
			ResistSpirit = 27,
			Alert = 51,
			Big = 52,
			Fast = 53,
			StaminaDrain = 54,
			EitrDrain = 55,
			Brutal = 56,
			ElementalChaos = 57
		}

		public static DataObjects.CreatureModifierCollection ActiveCreatureModifiers = new DataObjects.CreatureModifierCollection
		{
			MajorModifiers = new Dictionary<string, DataObjects.CreatureModifierConfiguration>(),
			MinorModifiers = new Dictionary<string, DataObjects.CreatureModifierConfiguration>(),
			BossModifiers = new Dictionary<string, DataObjects.CreatureModifierConfiguration>(),
			ModifierGlobalSettings = new DataObjects.GlobalModifierSettings()
		};

		public static Dictionary<Biome, Dictionary<string, List<DataObjects.ProbabilityEntry>>> biomeMajorProbabilityList = new Dictionary<Biome, Dictionary<string, List<DataObjects.ProbabilityEntry>>>();

		public static Dictionary<Biome, Dictionary<string, List<DataObjects.ProbabilityEntry>>> biomeMinorProbabilityList = new Dictionary<Biome, Dictionary<string, List<DataObjects.ProbabilityEntry>>>();

		public static Dictionary<Biome, Dictionary<string, List<DataObjects.ProbabilityEntry>>> biomeBossProbabilityList = new Dictionary<Biome, Dictionary<string, List<DataObjects.ProbabilityEntry>>>();

		public static Dictionary<string, GameObject> LoadedModifierEffects = new Dictionary<string, GameObject>();

		public static Dictionary<string, GameObject> LoadedSecondaryEffects = new Dictionary<string, GameObject>();

		public static Dictionary<string, Sprite> LoadedModifierSprites = new Dictionary<string, Sprite>();

		public static DataObjects.ModifierDisplayStyle SelectedModifierDisplayStyle = DataObjects.ModifierDisplayStyle.Icons;

		public static List<string> NonCombatCreatures = new List<string> { "Deer", "Hare", "Chicken", "Hen" };

		public static Dictionary<string, DataObjects.CreatureModifierDefinition> ModifierDefinitions = new Dictionary<string, DataObjects.CreatureModifierDefinition>
		{
			{
				ModifierNames.BossSummoner.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$bossSummoner_prefix1",
					NameSuffix = "$bossSummoner_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "summoner",
					SetupEvent = new <>f__AnonymousDelegate0<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Summoner.Setup)
				}
			},
			{
				ModifierNames.SoulEater.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$SoulEater_prefix1",
					NameSuffix = "$SoulEater_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "vortex"
				}
			},
			{
				ModifierNames.LifeLink.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$LifeLink_prefix1",
					NameSuffix = "$LifeLink_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "LifeLink2",
					SecondaryEffect = "LifelinkEffect"
				}
			},
			{
				ModifierNames.Evolving.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$Evolve_prefix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomFirst,
					StarVisual = "evolve"
				}
			},
			{
				ModifierNames.Brutal.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$Brutal_prefix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomFirst,
					VisualEffectStyle = DataObjects.VisualEffectStyle.bottom,
					StarVisual = "brutal",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Brutal.RunOnce)
				}
			},
			{
				ModifierNames.Fire.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$fire_prefix1",
					NameSuffix = "$fire_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					VisualEffectStyle = DataObjects.VisualEffectStyle.bottom,
					VisualEffect = "creatureFire",
					StarVisual = "flame",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Flame.RunOnce)
				}
			},
			{
				ModifierNames.Frost.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$frost_prefix1",
					NameSuffix = "$frost_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					VisualEffect = "creatureFrost",
					StarVisual = "snowflake",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Frost.RunOnce)
				}
			},
			{
				ModifierNames.Poison.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$poison_prefix1",
					NameSuffix = "$poison_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					VisualEffect = "creaturePoison",
					StarVisual = "poison",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Poison.RunOnce)
				}
			},
			{
				ModifierNames.Lightning.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$lightning_prefix1",
					NameSuffix = "$lightning_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					VisualEffectStyle = DataObjects.VisualEffectStyle.objectCenter,
					VisualEffect = "creatureLightning",
					StarVisual = "lightning",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Lightning.RunOnce)
				}
			},
			{
				ModifierNames.ElementalChaos.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$ElementalChaos_prefix",
					NameSuffix = "$ElementalChaos_suffix",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					VisualEffectStyle = DataObjects.VisualEffectStyle.objectCenter,
					VisualEffect = "creatureLightning",
					StarVisual = "eleChaos"
				}
			},
			{
				ModifierNames.Splitter.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$Splitter_prefix1",
					NameSuffix = "$Splitter_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "splitting"
				}
			},
			{
				ModifierNames.ResistPierce.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$ResistPierce_prefix1",
					NameSuffix = "$ResistPierce_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "pierceresist",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(ResistPierce.RunOnce)
				}
			},
			{
				ModifierNames.ResistSlash.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$ResistSlash_prefix1",
					NameSuffix = "$ResistSlash_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "slashresist",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(ResistSlash.RunOnce)
				}
			},
			{
				ModifierNames.ResistBlunt.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$ResistBlunt_prefix1",
					NameSuffix = "$ResistBlunt_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "bluntresist",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(ResistBlunt.RunOnce)
				}
			},
			{
				ModifierNames.ResistFire.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$ResistFire_prefix1",
					NameSuffix = "$ResistFire_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "FireRes",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(ResistFire.RunOnce)
				}
			},
			{
				ModifierNames.ResistFrost.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$ResistFrost_prefix1",
					NameSuffix = "$ResistFrost_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "FrostRes",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(ResistFrost.RunOnce)
				}
			},
			{
				ModifierNames.ResistPoison.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$ResistPoison_prefix1",
					NameSuffix = "$ResistPoison_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "PoisonRes",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(ResistPoison.RunOnce)
				}
			},
			{
				ModifierNames.ResistSpirit.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$ResistSpirit_prefix1",
					NameSuffix = "$ResistSpirit_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "SpiritRes",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(ResistSpirit.RunOnce)
				}
			},
			{
				ModifierNames.FireNova.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$FireNova_prefix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomFirst,
					StarVisual = "firenova",
					SecondaryEffect = "DeathFireNova"
				}
			},
			{
				ModifierNames.PoisonNova.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$PoisonNova_prefix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomFirst,
					StarVisual = "poisonnova",
					SecondaryEffect = "DeathPoisonNova"
				}
			},
			{
				ModifierNames.Lootbags.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$Lootbags_prefix1",
					NameSuffix = "$Lootbags_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					StarVisual = "lootbag",
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Lootbags.RunOnce)
				}
			},
			{
				ModifierNames.Alert.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$alert_prefix1",
					NameSuffix = "$alert_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					SetupEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Alert.Setup)
				}
			},
			{
				ModifierNames.Big.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$big_prefix1",
					NameSuffix = "$big_suffix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomBoth,
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Big.RunOnce)
				}
			},
			{
				ModifierNames.Fast.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$fast_prefix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomFirst,
					RunOnceEvent = new Action<Character, DataObjects.CreatureModConfig, DataObjects.CharacterCacheEntry>(Fast.RunOnce)
				}
			},
			{
				ModifierNames.StaminaDrain.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$staminaDrain_prefix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomFirst,
					StarVisual = "staminadrain"
				}
			},
			{
				ModifierNames.EitrDrain.ToString(),
				new DataObjects.CreatureModifierDefinition
				{
					NamePrefix = "$staminaDrain_prefix1",
					NamingConvention = DataObjects.NameSelectionStyle.RandomFirst,
					StarVisual = "eitrdrain"
				}
			}
		};

		public static DataObjects.DNum ModifierNamesLookupTable = new DataObjects.DNum(Enum.GetValues(typeof(ModifierNames)));

		private static DataObjects.CreatureModifierCollection CustomModifiers = new DataObjects.CreatureModifierCollection();

		private static DataObjects.CreatureModifierCollection APIAdded = new DataObjects.CreatureModifierCollection();

		private static readonly DataObjects.CreatureModifierCollection DefaultModifiers = new DataObjects.CreatureModifierCollection
		{
			BossModifiers = new Dictionary<string, DataObjects.CreatureModifierConfiguration>
			{
				{
					ModifierNames.BossSummoner.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 10f,
							PerlevelPower = 120f,
							BiomeObjects = new Dictionary<Biome, List<string>>
							{
								{
									(Biome)1,
									new List<string> { "Greyling" }
								},
								{
									(Biome)8,
									new List<string> { "Greydwarf_Shaman" }
								},
								{
									(Biome)2,
									new List<string> { "BlobElite" }
								},
								{
									(Biome)4,
									new List<string> { "Hatchling" }
								},
								{
									(Biome)16,
									new List<string> { "Goblin", "GoblinShaman", "GoblinBrute" }
								},
								{
									(Biome)512,
									new List<string> { "SeekerBrute", "Seeker" }
								},
								{
									(Biome)32,
									new List<string> { "Charred_Archer", "Charred_Melee" }
								}
							}
						}
					}
				},
				{
					ModifierNames.SoulEater.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.01f
						}
					}
				},
				{
					ModifierNames.LifeLink.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 0.3f,
							PerlevelPower = 0.02f
						}
					}
				},
				{
					ModifierNames.ResistPierce.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.02f,
							BasePower = 0.25f
						}
					}
				},
				{
					ModifierNames.Brutal.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0f,
							BasePower = 0.05f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				}
			},
			MajorModifiers = new Dictionary<string, DataObjects.CreatureModifierConfiguration>
			{
				{
					ModifierNames.Brutal.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0f,
							BasePower = 0.07f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.ElementalChaos.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.01f,
							BasePower = 0.3f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.Fire.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.01f,
							BasePower = 0.3f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.Frost.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.01f,
							BasePower = 0.3f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.Poison.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.05f,
							BasePower = 1f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.Lightning.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.05f,
							BasePower = 0.3f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.Splitter.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 2f,
							PerlevelPower = 0.1f
						}
					}
				},
				{
					ModifierNames.SoulEater.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.05f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.ResistPierce.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.02f,
							BasePower = 0.5f
						}
					}
				},
				{
					ModifierNames.ResistSlash.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.02f,
							BasePower = 0.5f
						}
					}
				},
				{
					ModifierNames.ResistBlunt.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.02f,
							BasePower = 0.5f
						}
					}
				}
			},
			MinorModifiers = new Dictionary<string, DataObjects.CreatureModifierConfiguration>
			{
				{
					ModifierNames.ResistFire.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 5f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 0.5f,
							PerlevelPower = 0.02f
						}
					}
				},
				{
					ModifierNames.ResistFrost.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 4f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 0.5f,
							PerlevelPower = 0.02f
						}
					}
				},
				{
					ModifierNames.ResistPoison.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 3f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 0.5f,
							PerlevelPower = 0.02f
						}
					}
				},
				{
					ModifierNames.ResistSpirit.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 2f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 0.5f,
							PerlevelPower = 0.02f
						}
					}
				},
				{
					ModifierNames.FireNova.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 2f,
							PerlevelPower = 0.1f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.PoisonNova.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 2f,
							PerlevelPower = 0.2f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.Lootbags.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							BasePower = 2f,
							PerlevelPower = 0.2f
						}
					}
				},
				{
					ModifierNames.Alert.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0.05f,
							BasePower = 2f
						}
					}
				},
				{
					ModifierNames.Big.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0f,
							BasePower = 0.3f
						}
					}
				},
				{
					ModifierNames.Fast.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 0f,
							BasePower = 0.2f
						}
					}
				},
				{
					ModifierNames.StaminaDrain.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 2f,
							BasePower = 3f,
							Config = new Dictionary<string, float>
							{
								{ "BlockReduction", 0.25f },
								{ "ParryReduction", 0.75f },
								{ "DodgeReduction", 1f }
							}
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.Evolving.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 5f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 1f,
							BasePower = 10f
						},
						UnallowedCreatures = NonCombatCreatures
					}
				},
				{
					ModifierNames.EitrDrain.ToString(),
					new DataObjects.CreatureModifierConfiguration
					{
						SelectionWeight = 10f,
						Config = new DataObjects.CreatureModConfig
						{
							PerlevelPower = 4f,
							BasePower = 10f,
							Config = new Dictionary<string, float>
							{
								{ "BlockReduction", 0.25f },
								{ "ParryReduction", 0.75f },
								{ "DodgeReduction", 1f }
							}
						},
						UnallowedCreatures = NonCombatCreatures,
						AllowedBiomes = new List<Biome>
						{
							(Biome)512,
							(Biome)32
						}
					}
				}
			},
			ModifierGlobalSettings = new DataObjects.GlobalModifierSettings
			{
				GlobalIgnorePrefabList = new List<string> { "piece_TrainingDummy" }
			}
		};

		internal static void ParseModifierDisplayStyle()
		{
			SelectedModifierDisplayStyle = (DataObjects.ModifierDisplayStyle)Enum.Parse(typeof(DataObjects.ModifierDisplayStyle), ValConfig.ModifierIconDisplayStyle.Value);
		}

		internal static void ModifierDisplayStyleChanged(object s, EventArgs e)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			ParseModifierDisplayStyle();
			LoadedModifierSprites.Clear();
			LoadPrefabs();
			foreach (ZDOID item in UIHudControl.characterExtendedHuds.Keys.ToList())
			{
				UIHudControl.RemoveExtendedHudFromCache(item);
			}
		}

		public static Dictionary<string, DataObjects.CreatureModifierConfiguration> GetModifiersOfType(DataObjects.ModifierType type)
		{
			return type switch
			{
				DataObjects.ModifierType.Minor => ActiveCreatureModifiers.MinorModifiers, 
				DataObjects.ModifierType.Boss => ActiveCreatureModifiers.BossModifiers, 
				_ => ActiveCreatureModifiers.MajorModifiers, 
			};
		}

		public static DataObjects.CreatureModConfig GetConfig(string name, DataObjects.ModifierType type = DataObjects.ModifierType.Major)
		{
			switch (type)
			{
			case DataObjects.ModifierType.Minor:
				if (!ActiveCreatureModifiers.MinorModifiers.ContainsKey(name))
				{
					return new DataObjects.CreatureModConfig();
				}
				return ActiveCreatureModifiers.MinorModifiers[name].Config;
			case DataObjects.ModifierType.Boss:
				if (!ActiveCreatureModifiers.BossModifiers.ContainsKey(name))
				{
					return new DataObjects.CreatureModConfig();
				}
				return ActiveCreatureModifiers.BossModifiers[name].Config;
			default:
				if (!ActiveCreatureModifiers.MajorModifiers.ContainsKey(name))
				{
					return new DataObjects.CreatureModConfig();
				}
				return ActiveCreatureModifiers.MajorModifiers[name].Config;
			}
		}

		public static DataObjects.CreatureModifierConfiguration GetModifierDef(string name, DataObjects.ModifierType type = DataObjects.ModifierType.Major)
		{
			switch (type)
			{
			case DataObjects.ModifierType.Minor:
				if (!ActiveCreatureModifiers.MinorModifiers.ContainsKey(name))
				{
					return new DataObjects.CreatureModifierConfiguration();
				}
				return ActiveCreatureModifiers.MinorModifiers[name];
			case DataObjects.ModifierType.Boss:
				if (!ActiveCreatureModifiers.BossModifiers.ContainsKey(name))
				{
					return new DataObjects.CreatureModifierConfiguration();
				}
				return ActiveCreatureModifiers.BossModifiers[name];
			default:
				if (!ActiveCreatureModifiers.MajorModifiers.ContainsKey(name))
				{
					return new DataObjects.CreatureModifierConfiguration();
				}
				return ActiveCreatureModifiers.MajorModifiers[name];
			}
		}

		public static List<DataObjects.ProbabilityEntry> LazyCacheCreatureModifierSelect(string creature, Biome biome, DataObjects.ModifierType type = DataObjects.ModifierType.Major)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			switch (type)
			{
			case DataObjects.ModifierType.Major:
				if (biomeMajorProbabilityList.ContainsKey(biome) && biomeMajorProbabilityList[biome].ContainsKey(creature))
				{
					return biomeMajorProbabilityList[biome][creature];
				}
				break;
			case DataObjects.ModifierType.Minor:
				if (biomeMinorProbabilityList.ContainsKey(biome) && biomeMinorProbabilityList[biome].ContainsKey(creature))
				{
					return biomeMinorProbabilityList[biome][creature];
				}
				break;
			case DataObjects.ModifierType.Boss:
				if (biomeBossProbabilityList.ContainsKey(biome) && biomeBossProbabilityList[biome].ContainsKey(creature))
				{
					return biomeBossProbabilityList[biome][creature];
				}
				break;
			}
			return type switch
			{
				DataObjects.ModifierType.Boss => BuildCacheProbabilities(creature, biome, ActiveCreatureModifiers.BossModifiers, biomeBossProbabilityList), 
				DataObjects.ModifierType.Major => BuildCacheProbabilities(creature, biome, ActiveCreatureModifiers.MajorModifiers, biomeMajorProbabilityList), 
				_ => BuildCacheProbabilities(creature, biome, ActiveCreatureModifiers.MinorModifiers, biomeMinorProbabilityList), 
			};
		}

		private static List<DataObjects.ProbabilityEntry> BuildCacheProbabilities(string creature, Biome biome, Dictionary<string, DataObjects.CreatureModifierConfiguration> activeMods, Dictionary<Biome, Dictionary<string, List<DataObjects.ProbabilityEntry>>> probabilitiesCache)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (probabilitiesCache.ContainsKey(biome) && probabilitiesCache[biome].ContainsKey(creature))
			{
				return probabilitiesCache[biome][creature];
			}
			List<DataObjects.ProbabilityEntry> list = BuildProbabilityEntries(creature, biome, activeMods);
			if (!probabilitiesCache.ContainsKey(biome))
			{
				probabilitiesCache.Add(biome, new Dictionary<string, List<DataObjects.ProbabilityEntry>> { { creature, list } });
			}
			else
			{
				probabilitiesCache[biome].Add(creature, list);
			}
			return list;
		}

		private static List<DataObjects.ProbabilityEntry> BuildProbabilityEntries(string creature, Biome biome, Dictionary<string, DataObjects.CreatureModifierConfiguration> modifiers)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			List<DataObjects.ProbabilityEntry> list = new List<DataObjects.ProbabilityEntry>();
			foreach (KeyValuePair<string, DataObjects.CreatureModifierConfiguration> modifier in modifiers)
			{
				if (!modifier.Value.Enabled || (modifier.Value.UnallowedCreatures != null && modifier.Value.UnallowedCreatures.Contains(creature)) || (modifier.Value.AllowedBiomes != null && !modifier.Value.AllowedBiomes.Contains(biome)))
				{
					continue;
				}
				if (modifier.Value.AllowedCreatures != null && modifier.Value.AllowedCreatures.Count > 0)
				{
					if (!modifier.Value.AllowedCreatures.Contains(creature))
					{
						continue;
					}
					list.Add(new DataObjects.ProbabilityEntry
					{
						Name = modifier.Key,
						SelectionWeight = modifier.Value.SelectionWeight
					});
				}
				list.Add(new DataObjects.ProbabilityEntry
				{
					Name = modifier.Key,
					SelectionWeight = modifier.Value.SelectionWeight
				});
			}
			return list;
		}

		private static void UpdateModifiers(DataObjects.CreatureModifierCollection creatureMods = null, DataObjects.CreatureModifierCollection APIcreatureMods = null)
		{
			ActiveCreatureModifiers.MajorModifiers.Clear();
			ActiveCreatureModifiers.MinorModifiers.Clear();
			ActiveCreatureModifiers.BossModifiers.Clear();
			Logger.LogDebug("Setting config definitions");
			if (creatureMods != null)
			{
				CustomModifiers = creatureMods;
			}
			if (APIcreatureMods != null)
			{
				APIAdded = APIcreatureMods;
			}
			if (CustomModifiers.ModifierGlobalSettings != null)
			{
				ActiveCreatureModifiers.ModifierGlobalSettings = CustomModifiers.ModifierGlobalSettings;
			}
			else
			{
				ActiveCreatureModifiers.ModifierGlobalSettings = DefaultModifiers.ModifierGlobalSettings;
			}
			Logger.LogDebug("Merging config Major mod definitions");
			if (CustomModifiers.MajorModifiers != null && CustomModifiers.MajorModifiers.Count > 0)
			{
				Extensions.AddRange<string, DataObjects.CreatureModifierConfiguration>(ActiveCreatureModifiers.MajorModifiers, CustomModifiers.MajorModifiers);
			}
			if (APIAdded.MajorModifiers != null && APIAdded.MajorModifiers.Count > 0)
			{
				Extensions.AddRange<string, DataObjects.CreatureModifierConfiguration>(ActiveCreatureModifiers.MajorModifiers, APIAdded.MajorModifiers);
			}
			if (APIAdded.MajorModifiers == null && CustomModifiers.MajorModifiers == null)
			{
				Extensions.AddRange<string, DataObjects.CreatureModifierConfiguration>(ActiveCreatureModifiers.MajorModifiers, DefaultModifiers.MajorModifiers);
			}
			Logger.LogDebug("Merging config Minor mod definitions");
			if (CustomModifiers.MinorModifiers != null && CustomModifiers.MinorModifiers.Count > 0)
			{
				Extensions.AddRange<string, DataObjects.CreatureModifierConfiguration>(ActiveCreatureModifiers.MinorModifiers, CustomModifiers.MinorModifiers);
			}
			if (APIAdded.MinorModifiers != null && APIAdded.MinorModifiers.Count > 0)
			{
				Extensions.AddRange<string, DataObjects.CreatureModifierConfiguration>(ActiveCreatureModifiers.MinorModifiers, APIAdded.MinorModifiers);
			}
			if (APIAdded.MinorModifiers == null && CustomModifiers.MinorModifiers == null)
			{
				Extensions.AddRange<string, DataObjects.CreatureModifierConfiguration>(ActiveCreatureModifiers.MinorModifiers, DefaultModifiers.MinorModifiers);
			}
			Logger.LogDebug("Merging config Boss mod definitions");
			if (CustomModifiers.BossModifiers != null && CustomModifiers.BossModifiers.Count > 0)
			{
				Extensions.AddRange<string, DataObjects.CreatureModifierConfiguration>(ActiveCreatureModifiers.BossModifiers, CustomModifiers.BossModifiers);
			}
			if (APIAdded.BossModifiers != null && APIAdded.BossModifiers.Count > 0)
			{
				Extensions.AddRange<string, DataObjects.CreatureModifierConfiguration>(ActiveCreatureModifiers.BossModifiers, APIAdded.BossModifiers);
			}
			if (APIAdded.BossModifiers == null && CustomModifiers.BossModifiers == null)
			{
				Extensions.AddRange<string, DataObjects.CreatureModifierConfiguration>(ActiveCreatureModifiers.BossModifiers, DefaultModifiers.BossModifiers);
			}
		}

		internal static string GetModifierDefaultConfig()
		{
			return DataObjects.yamlSerializer.Serialize((object)DefaultModifiers);
		}

		internal static void ClearProbabilityCaches(object s, EventArgs e)
		{
			ClearProbabilityCaches();
		}

		internal static void ClearProbabilityCaches()
		{
			biomeMajorProbabilityList.Clear();
			biomeMinorProbabilityList.Clear();
			biomeBossProbabilityList.Clear();
		}

		internal static bool UpdateModifierConfig(string yaml)
		{
			try
			{
				UpdateModifiers(DataObjects.yamlDeserializer.Deserialize<DataObjects.CreatureModifierCollection>(yaml));
				LoadPrefabs();
				Logger.LogDebug("Loading Modifier Configuration.");
			}
			catch (Exception ex)
			{
				UpdateModifiers(DefaultModifiers);
				LoadPrefabs();
				StarLevelSystem.Log.LogError((object)("Failed to parse Modifier YAML, reverting to defaults error: " + ex.Message));
				return false;
			}
			return true;
		}

		internal static void LoadPrefabs()
		{
			if ((Object)(object)StarLevelSystem.EmbeddedResourceBundle == (Object)null)
			{
				Logger.LogDebug("Embedded asset bundle is unavailable (game exiting or world unloading); skipping modifier prefab load.");
				return;
			}
			if (ActiveCreatureModifiers.MinorModifiers != null)
			{
				foreach (KeyValuePair<string, DataObjects.CreatureModifierConfiguration> minorModifier in ActiveCreatureModifiers.MinorModifiers)
				{
					Logger.LogDebug($"Loading assets for: {minorModifier}");
					ModifierDefinitions[minorModifier.Key].LoadAndSetGameObjects();
				}
			}
			if (ActiveCreatureModifiers.MajorModifiers != null)
			{
				foreach (KeyValuePair<string, DataObjects.CreatureModifierConfiguration> majorModifier in ActiveCreatureModifiers.MajorModifiers)
				{
					Logger.LogDebug($"Loading assets for: {majorModifier}");
					ModifierDefinitions[majorModifier.Key].LoadAndSetGameObjects();
				}
			}
			if (ActiveCreatureModifiers.BossModifiers == null)
			{
				return;
			}
			foreach (KeyValuePair<string, DataObjects.CreatureModifierConfiguration> bossModifier in ActiveCreatureModifiers.BossModifiers)
			{
				Logger.LogDebug($"Loading assets for: {bossModifier}");
				ModifierDefinitions[bossModifier.Key].LoadAndSetGameObjects();
			}
		}

		internal static void Init()
		{
			UpdateModifierConfig(File.ReadAllText(ValConfig.creatureModifierFilePath));
		}
	}
	public static class LevelSystemData
	{
		public static DataObjects.CreatureLevelSettings SLE_Level_Settings = DefaultConfiguration;

		public static readonly DataObjects.CreatureLevelSettings DefaultConfiguration = new DataObjects.CreatureLevelSettings
		{
			CustomLevelupGenerators = new Dictionary<string, List<DataObjects.LevelGenerator>>
			{
				{
					"early_game",
					new List<DataObjects.LevelGenerator>
					{
						new DataObjects.LevelGenerator
						{
							MinLevel = 0,
							MaxLevel = 6,
							LevelUpChance = 0.2f,
							LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
						}
					}
				},
				{
					"late_game",
					new List<DataObjects.LevelGenerator>
					{
						new DataObjects.LevelGenerator
						{
							MinLevel = 1,
							MaxLevel = 25,
							LevelUpChance = 0.35f,
							LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Gaussian,
							GaussianOffset = 0.25f
						}
					}
				}
			},
			DefaultCreatureLevelUpChance = new SortedDictionary<int, float>
			{
				{ 1, 20f },
				{ 2, 10f },
				{ 3, 5f },
				{ 4, 2f },
				{ 5, 1f },
				{ 6, 0.5f },
				{ 7, 0.25f },
				{ 8, 0.125f },
				{ 9, 0.0625f },
				{ 10, 0.0312f },
				{ 11, 0.0156f },
				{ 12, 0.0078f },
				{ 13, 0.0039f },
				{ 14, 0.0019f },
				{ 15, 0.0015f },
				{ 16, 0.001f },
				{ 17, 0.0009f },
				{ 18, 0.0008f },
				{ 19, 0.0007f },
				{ 20, 0.0006f },
				{ 21, 0.0005f },
				{ 22, 0.0004f },
				{ 23, 0.0003f },
				{ 24, 0.0002f },
				{ 25, 0.0001f }
			},
			BiomeConfiguration = new Dictionary<Biome, DataObjects.BiomeSpecificSetting>
			{
				{
					(Biome)895,
					new DataObjects.BiomeSpecificSetting
					{
						SpawnRateModifier = 1.1f,
						DistanceScaleModifier = 1.5f,
						DamageRecievedModifiers = new Dictionary<DataObjects.DamageType, float> { 
						{
							DataObjects.DamageType.Poison,
							1.5f
						} },
						NightSettings = new DataObjects.BiomeNightSettings
						{
							NightLevelUpChanceScaler = 1.5f
						}
					}
				},
				{
					(Biome)1,
					new DataObjects.BiomeSpecificSetting
					{
						BiomeMaxLevelOverride = 4
					}
				},
				{
					(Biome)8,
					new DataObjects.BiomeSpecificSetting
					{
						BiomeMaxLevelOverride = 6
					}
				},
				{
					(Biome)2,
					new DataObjects.BiomeSpecificSetting
					{
						BiomeMaxLevelOverride = 10
					}
				},
				{
					(Biome)4,
					new DataObjects.BiomeSpecificSetting
					{
						BiomeMaxLevelOverride = 14
					}
				},
				{
					(Biome)16,
					new DataObjects.BiomeSpecificSetting
					{
						BiomeMaxLevelOverride = 18
					}
				},
				{
					(Biome)512,
					new DataObjects.BiomeSpecificSetting
					{
						BiomeMaxLevelOverride = 22
					}
				},
				{
					(Biome)32,
					new DataObjects.BiomeSpecificSetting
					{
						DistanceScaleModifier = 0.5f,
						BiomeMaxLevelOverride = 26
					}
				},
				{
					(Biome)64,
					new DataObjects.BiomeSpecificSetting
					{
						DistanceScaleModifier = 0.5f,
						BiomeMaxLevelOverride = 26
					}
				}
			},
			CreatureConfiguration = new Dictionary<string, DataObjects.CreatureSpecificSetting>
			{
				{
					"piece_TrainingDummy",
					new DataObjects.CreatureSpecificSetting
					{
						CreatureMaxLevelOverride = 11,
						SpawnRateModifier = 1f,
						CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
						{
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								1.05f
							},
							{
								DataObjects.CreatureBaseAttribute.BaseDamage,
								0.95f
							},
							{
								DataObjects.CreatureBaseAttribute.Speed,
								1.05f
							},
							{
								DataObjects.CreatureBaseAttribute.Size,
								1.05f
							},
							{
								DataObjects.CreatureBaseAttribute.AttackSpeed,
								1.05f
							}
						},
						CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float>
						{
							{
								DataObjects.CreaturePerLevelAttribute.HealthPerLevel,
								0.3f
							},
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.05f
							},
							{
								DataObjects.CreaturePerLevelAttribute.SizePerLevel,
								0.005f
							}
						},
						CustomCreatureLevelUpChance = new SortedDictionary<int, float>
						{
							{ 1, 100f },
							{ 2, 100f },
							{ 3, 0f }
						}
					}
				},
				{
					"Lox",
					new DataObjects.CreatureSpecificSetting
					{
						CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
						{
							DataObjects.CreaturePerLevelAttribute.SpeedPerLevel,
							-0.01f
						} }
					}
				},
				{
					"Troll",
					new DataObjects.CreatureSpecificSetting
					{
						SpawnRateModifier = 1f,
						CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
						{
							DataObjects.CreaturePerLevelAttribute.SizePerLevel,
							0.05f
						} }
					}
				},
				{
					"Bjorn",
					new DataObjects.CreatureSpecificSetting
					{
						SpawnRateModifier = 1f,
						CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
						{
							DataObjects.CreaturePerLevelAttribute.SizePerLevel,
							0.05f
						} }
					}
				},
				{
					"GoblinBruteBros",
					new DataObjects.CreatureSpecificSetting
					{
						SpawnRateModifier = 1f
					}
				},
				{
					"GoblinShaman_Hildir",
					new DataObjects.CreatureSpecificSetting
					{
						SpawnRateModifier = 1f
					}
				},
				{
					"GoblinBrute_Hildir",
					new DataObjects.CreatureSpecificSetting
					{
						SpawnRateModifier = 1f
					}
				},
				{
					"Skeleton_Hildir",
					new DataObjects.CreatureSpecificSetting
					{
						SpawnRateModifier = 1f
					}
				},
				{
					"Fenring_Cultist_Hildir",
					new DataObjects.CreatureSpecificSetting
					{
						SpawnRateModifier = 1f
					}
				},
				{
					"Charred_Melee_Dyrnwyn",
					new DataObjects.CreatureSpecificSetting
					{
						SpawnRateModifier = 1f
					}
				}
			},
			EnableDistanceLevelBonus = true,
			DistanceLevelBonus = new SortedDictionary<int, SortedDictionary<int, float>>
			{
				{
					750,
					new SortedDictionary<int, float>
					{
						{ 1, 15f },
						{ 2, 5f },
						{ 3, 1f }
					}
				},
				{
					1200,
					new SortedDictionary<int, float>
					{
						{ 1, 18f },
						{ 2, 7f },
						{ 3, 1.5f },
						{ 4, 0.5f }
					}
				},
				{
					2000,
					new SortedDictionary<int, float>
					{
						{ 1, 24f },
						{ 2, 10f },
						{ 3, 3f },
						{ 4, 1f },
						{ 5, 0.5f }
					}
				},
				{
					3000,
					new SortedDictionary<int, float>
					{
						{ 1, 32f },
						{ 2, 16f },
						{ 3, 8f },
						{ 4, 4f },
						{ 5, 2f },
						{ 6, 1f }
					}
				},
				{
					4000,
					new SortedDictionary<int, float>
					{
						{ 1, 40f },
						{ 2, 25f },
						{ 3, 12f },
						{ 4, 6f },
						{ 5, 3f },
						{ 6, 2f },
						{ 7, 1f },
						{ 8, 0.5f }
					}
				},
				{
					5000,
					new SortedDictionary<int, float>
					{
						{ 1, 50f },
						{ 2, 35f },
						{ 3, 18f },
						{ 4, 9f },
						{ 5, 6f },
						{ 6, 3f },
						{ 7, 2f },
						{ 8, 1f },
						{ 9, 0.5f },
						{ 10, 0.25f }
					}
				},
				{
					6000,
					new SortedDictionary<int, float>
					{
						{ 1, 60f },
						{ 2, 40f },
						{ 3, 20f },
						{ 4, 10f },
						{ 5, 8f },
						{ 6, 6f },
						{ 7, 4f },
						{ 8, 2f },
						{ 9, 1f },
						{ 10, 0.5f },
						{ 11, 0.25f },
						{ 12, 0.12f }
					}
				},
				{
					7000,
					new SortedDictionary<int, float>
					{
						{ 1, 70f },
						{ 2, 50f },
						{ 3, 25f },
						{ 4, 12f },
						{ 5, 10f },
						{ 6, 8f },
						{ 7, 6f },
						{ 8, 4f },
						{ 9, 2f },
						{ 10, 1f },
						{ 11, 0.5f },
						{ 12, 0.25f },
						{ 13, 0.12f },
						{ 14, 0.06f }
					}
				},
				{
					8000,
					new SortedDictionary<int, float>
					{
						{ 1, 80f },
						{ 2, 60f },
						{ 3, 40f },
						{ 4, 20f },
						{ 5, 15f },
						{ 6, 12f },
						{ 7, 10f },
						{ 8, 8f },
						{ 9, 6f },
						{ 10, 4f },
						{ 11, 2f },
						{ 12, 1f },
						{ 13, 0.5f },
						{ 14, 0.25f },
						{ 15, 0.12f },
						{ 16, 0.06f }
					}
				},
				{
					9100,
					new SortedDictionary<int, float>
					{
						{ 1, 100f },
						{ 2, 80f },
						{ 3, 60f },
						{ 4, 40f },
						{ 5, 30f },
						{ 6, 20f },
						{ 7, 16f },
						{ 8, 14f },
						{ 9, 12f },
						{ 10, 10f },
						{ 11, 8f },
						{ 12, 4f },
						{ 13, 2f },
						{ 14, 1f },
						{ 15, 0.5f },
						{ 16, 0.25f },
						{ 17, 0.12f },
						{ 18, 0.06f }
					}
				}
			},
			EnableConditionalCreatureLevelupChance = false,
			ConditionalCreatureLevelupChance = new Dictionary<string, Dictionary<Biome, DataObjects.ConditionalLevelupChance>>
			{
				{
					"defeated_eikthyr",
					new Dictionary<Biome, DataObjects.ConditionalLevelupChance> { 
					{
						(Biome)1,
						new DataObjects.ConditionalLevelupChance
						{
							LevelupGenerators = new List<DataObjects.LevelGenerator>
							{
								new DataObjects.LevelGenerator
								{
									MinLevel = 1,
									MaxLevel = 8,
									LevelUpChance = 0.25f,
									LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
								}
							}
						}
					} }
				},
				{
					"defeated_gdking",
					new Dictionary<Biome, DataObjects.ConditionalLevelupChance>
					{
						{
							(Biome)1,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 12,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)8,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 1,
										MaxLevel = 8,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						}
					}
				},
				{
					"defeated_bonemass",
					new Dictionary<Biome, DataObjects.ConditionalLevelupChance>
					{
						{
							(Biome)1,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 3,
										MaxLevel = 16,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)8,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 12,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)2,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 1,
										MaxLevel = 8,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						}
					}
				},
				{
					"defeated_dragon",
					new Dictionary<Biome, DataObjects.ConditionalLevelupChance>
					{
						{
							(Biome)1,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 4,
										MaxLevel = 20,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)8,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 3,
										MaxLevel = 16,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)2,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 12,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)4,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 1,
										MaxLevel = 8,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						}
					}
				},
				{
					"defeated_goblinking",
					new Dictionary<Biome, DataObjects.ConditionalLevelupChance>
					{
						{
							(Biome)1,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 5,
										MaxLevel = 24,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)8,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 4,
										MaxLevel = 20,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)2,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 3,
										MaxLevel = 16,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)4,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 12,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)16,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 1,
										MaxLevel = 8,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						}
					}
				},
				{
					"defeated_queen",
					new Dictionary<Biome, DataObjects.ConditionalLevelupChance>
					{
						{
							(Biome)1,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 6,
										MaxLevel = 30,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)8,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 5,
										MaxLevel = 24,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)2,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 4,
										MaxLevel = 20,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)4,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 3,
										MaxLevel = 16,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)16,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 12,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)512,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 1,
										MaxLevel = 8,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						}
					}
				},
				{
					"defeated_fader",
					new Dictionary<Biome, DataObjects.ConditionalLevelupChance>
					{
						{
							(Biome)1,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 6,
										MaxLevel = 30,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)8,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 5,
										MaxLevel = 24,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)2,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 4,
										MaxLevel = 20,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)4,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 3,
										MaxLevel = 16,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)16,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 12,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						},
						{
							(Biome)512,
							new DataObjects.ConditionalLevelupChance
							{
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 1,
										MaxLevel = 8,
										LevelUpChance = 0.25f,
										LevelupCalculationStyle = DataObjects.LevelupCalculationStyle.Exponential
									}
								}
							}
						}
					}
				}
			}
		};

		internal static void Init()
		{
			SLE_Level_Settings = DefaultConfiguration;
			Colorization.UpdateMapColorSelection();
			Colorization.UpdateZoneOverlayColorSelection();
			try
			{
				UpdateYamlConfig(File.ReadAllText(ValConfig.levelsFilePath));
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"There was an error updating the Creature Level values, defaults will be used. Exception: {arg}");
			}
		}

		public static string YamlDefaultConfig()
		{
			return DataObjects.yamlSerializer.Serialize((object)DefaultConfiguration);
		}

		public static bool UpdateYamlConfig(string yaml)
		{
			try
			{
				SLE_Level_Settings = DataObjects.yamlDeserializer.Deserialize<DataObjects.CreatureLevelSettings>(yaml);
				ApplyLevelupGenerators();
				Logger.LogDebug("Loaded new Star Level Creature settings, updating loaded creatures...");
				DistanceScaleSystem.DelayedMinimapSetup();
				CompositeLazyCache.FlushCache();
				ConditionalScaleSystem.ResetCache();
				((MonoBehaviour)TaskRunner.Run()).StartCoroutine(UpdateCreatureAttributes(new List<Character>(Resources.FindObjectsOfTypeAll<Character>())));
			}
			catch (Exception ex)
			{
				StarLevelSystem.Log.LogError((object)("Failed to parse CreatureLevelSettings YAML: " + ex.Message));
				return false;
			}
			return true;
		}

		private static void ApplyLevelupGenerators()
		{
			DataObjects.CreatureLevelSettings sLE_Level_Settings = SLE_Level_Settings;
			if (sLE_Level_Settings == null)
			{
				return;
			}
			SortedDictionary<int, float> sortedDictionary = LevelGeneratorResolver.BuildLevelupChance(sLE_Level_Settings.DefaultLevelupGenerators, sLE_Level_Settings.DefaultLevelupGeneratorRefs);
			if (sortedDictionary != null)
			{
				sLE_Level_Settings.DefaultCreatureLevelUpChance = sortedDictionary;
			}
			if (sLE_Level_Settings.BiomeConfiguration != null)
			{
				foreach (DataObjects.BiomeSpecificSetting value in sLE_Level_Settings.BiomeConfiguration.Values)
				{
					if (value != null)
					{
						SortedDictionary<int, float> sortedDictionary2 = LevelGeneratorResolver.BuildLevelupChance(value.LevelupGenerators, value.LevelupGeneratorRefs);
						if (sortedDictionary2 != null)
						{
							value.CustomCreatureLevelUpChance = sortedDictionary2;
						}
					}
				}
			}
			if (sLE_Level_Settings.CreatureConfiguration == null)
			{
				return;
			}
			foreach (DataObjects.CreatureSpecificSetting value2 in sLE_Level_Settings.CreatureConfiguration.Values)
			{
				if (value2 != null)
				{
					SortedDictionary<int, float> sortedDictionary3 = LevelGeneratorResolver.BuildLevelupChance(value2.LevelupGenerators, value2.LevelupGeneratorRefs);
					if (sortedDictionary3 != null)
					{
						value2.CustomCreatureLevelUpChance = sortedDictionary3;
					}
				}
			}
		}

		internal static IEnumerator UpdateCreatureAttributes(List<Character> characters)
		{
			int num = 0;
			WaitForSeconds sleep = new WaitForSeconds(0.1f);
			HealthModifications.ForceUpdateHealth = true;
			SizeModifications.ForceUpdateSize = true;
			foreach (Character character in characters)
			{
				if (num >= ValConfig.NumberOfCacheUpdatesPerFrame.Value)
				{
					yield return sleep;
					num = 0;
				}
				if (!((Object)(object)character == (Object)null) && !((Object)(object)character.m_nview == (Object)null) && character.m_nview.IsValid())
				{
					CreatureSetupControl.CreatureSetup(character, 0, multiply: true, 0f);
					num++;
				}
			}
			HealthModifications.ForceUpdateHealth = false;
			SizeModifications.ForceUpdateSize = false;
		}
	}
	public static class LootSystemData
	{
		public static DataObjects.LootSettings DefaultDropConfiguration = new DataObjects.LootSettings
		{
			CharacterSpecificLoot = new Dictionary<string, List<DataObjects.ExtendedCharacterDrop>>
			{
				{
					"BlobElite",
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "Ooze",
								Min = 2,
								Max = 3
							},
							AmountScaleFactor = 0.5f
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "IronScrap",
								Min = 1,
								Max = 1,
								Chance = 0.33f
							},
							AmountScaleFactor = 0.2f
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "TrophyBlob",
								Min = 1,
								Max = 1,
								Chance = 0.1f
							},
							ChanceScaleFactor = 0.01f,
							MaxScaledAmount = 1
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "Blob",
								Min = 2,
								Max = 2
							},
							AmountScaleFactor = 0.5f,
							MaxScaledAmount = 6
						}
					}
				},
				{
					"GoblinBruteBros",
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "GoblinShaman_Hildir",
								Min = 1,
								Max = 1,
								Chance = 1f,
								DontScale = true
							},
							DoesNotScale = true
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "TrophyGoblinBruteBrosBrute",
								Min = 1,
								Max = 1,
								Chance = 1f,
								DontScale = true
							},
							DoesNotScale = true
						}
					}
				},
				{
					"Tick",
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "GiantBloodSack",
								Min = 1,
								Max = 1,
								Chance = 1f
							},
							AmountScaleFactor = 0.5f
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "TrophyTick",
								Min = 1,
								Max = 1,
								Chance = 0.05f
							},
							ChanceScaleFactor = 0.01f,
							MaxScaledAmount = 1
						}
					}
				}
			},
			NonCharacterSpecificLoot = new Dictionary<string, List<DataObjects.ExtendedObjectDrop>>
			{
				{
					"caverock_ice_stalagtite_falling",
					new List<DataObjects.ExtendedObjectDrop>
					{
						new DataObjects.ExtendedObjectDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "Crystal",
								Min = 1,
								Max = 3,
								Chance = 0.3f,
								DontScale = true
							}
						}
					}
				},
				{
					"EvilHeart_Forest",
					new List<DataObjects.ExtendedObjectDrop>
					{
						new DataObjects.ExtendedObjectDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = "AncientSeed",
								Min = 1,
								Max = 1,
								OnePerPlayer = true
							},
							MaxScaledAmount = 3
						}
					}
				}
			},
			EnableDistanceLootModifier = true,
			DistanceLootModifier = new SortedDictionary<int, DataObjects.DistanceLootModifier>
			{
				{
					1250,
					new DataObjects.DistanceLootModifier
					{
						ChanceScaleFactorBonus = 0f,
						MinAmountScaleFactorBonus = 0.02f,
						MaxAmountScaleFactorBonus = 0.02f
					}
				},
				{
					2500,
					new DataObjects.DistanceLootModifier
					{
						ChanceScaleFactorBonus = 0f,
						MinAmountScaleFactorBonus = 0.05f,
						MaxAmountScaleFactorBonus = 0.05f
					}
				},
				{
					3750,
					new DataObjects.DistanceLootModifier
					{
						ChanceScaleFactorBonus = 0f,
						MinAmountScaleFactorBonus = 0.08f,
						MaxAmountScaleFactorBonus = 0.08f
					}
				},
				{
					5000,
					new DataObjects.DistanceLootModifier
					{
						ChanceScaleFactorBonus = 0f,
						MinAmountScaleFactorBonus = 0.12f,
						MaxAmountScaleFactorBonus = 0.12f
					}
				},
				{
					6250,
					new DataObjects.DistanceLootModifier
					{
						ChanceScaleFactorBonus = 0f,
						MinAmountScaleFactorBonus = 0.15f,
						MaxAmountScaleFactorBonus = 0.15f
					}
				},
				{
					7500,
					new DataObjects.DistanceLootModifier
					{
						ChanceScaleFactorBonus = 0f,
						MinAmountScaleFactorBonus = 0.2f,
						MaxAmountScaleFactorBonus = 0.2f
					}
				},
				{
					8750,
					new DataObjects.DistanceLootModifier
					{
						ChanceScaleFactorBonus = 0f,
						MinAmountScaleFactorBonus = 0.35f,
						MaxAmountScaleFactorBonus = 0.35f
					}
				}
			}
		};

		public static DataObjects.LootSettings SLS_Drop_Settings { get; set; }

		internal static void Init()
		{
			SLS_Drop_Settings = DefaultDropConfiguration;
			try
			{
				UpdateYamlConfig(File.ReadAllText(ValConfig.creatureLootFilePath));
			}
			catch (Exception arg)
			{
				SLS_Drop_Settings = DefaultDropConfiguration;
				Logger.LogWarning((object)$"There was an error updating the Loot Level values, defaults will be used. Exception: {arg}");
			}
		}

		public static string YamlDefaultConfig()
		{
			return DataObjects.yamlSerializer.Serialize((object)DefaultDropConfiguration);
		}

		internal static void AttachPrefabsWhenReady()
		{
			AttachLootPrefabs(SLS_Drop_Settings);
		}

		public static void AttachLootPrefabs(DataObjects.LootSettings lootconfig)
		{
			if (lootconfig == null)
			{
				return;
			}
			if (lootconfig.CharacterSpecificLoot != null)
			{
				foreach (KeyValuePair<string, List<DataObjects.ExtendedCharacterDrop>> item in lootconfig.CharacterSpecificLoot)
				{
					foreach (DataObjects.ExtendedCharacterDrop item2 in item.Value)
					{
						item2.ToCharacterDrop();
					}
				}
			}
			if (lootconfig.NonCharacterSpecificLoot == null)
			{
				return;
			}
			foreach (KeyValuePair<string, List<DataObjects.ExtendedObjectDrop>> item3 in lootconfig.NonCharacterSpecificLoot)
			{
				foreach (DataObjects.ExtendedObjectDrop item4 in item3.Value)
				{
					item4.ResolveDropPrefab();
				}
			}
		}

		public static bool UpdateYamlConfig(string yaml)
		{
			try
			{
				SLS_Drop_Settings = DataObjects.yamlDeserializer.Deserialize<DataObjects.LootSettings>(yaml);
				AttachLootPrefabs(SLS_Drop_Settings);
				Logger.LogDebug("Loaded new Creature loot configuration.");
			}
			catch (Exception ex)
			{
				StarLevelSystem.Log.LogError((object)("Failed to parse LootLevelSettings YAML: " + ex.Message));
				return false;
			}
			return true;
		}

		public static void SetCustomLoot(Character chara, List<DataObjects.ExtendedCharacterDrop> loot)
		{
			if (!((Object)(object)chara?.m_nview == (Object)null) && chara.m_nview.GetZDO() != null && loot != null)
			{
				chara.m_nview.GetZDO().Set(DataObjects.SLS_CUSTOM_LOOT, DataObjects.yamlSerializer.Serialize((object)loot));
			}
		}

		public static List<DataObjects.ExtendedCharacterDrop> GetCustomLoot(Character chara)
		{
			if ((Object)(object)chara?.m_nview == (Object)null || chara.m_nview.GetZDO() == null)
			{
				return null;
			}
			string text = chara.m_nview.GetZDO().GetString(DataObjects.SLS_CUSTOM_LOOT, (string)null);
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			try
			{
				List<DataObjects.ExtendedCharacterDrop> list = DataObjects.yamlDeserializer.Deserialize<List<DataObjects.ExtendedCharacterDrop>>(text);
				foreach (DataObjects.ExtendedCharacterDrop item in list)
				{
					item.ToCharacterDrop();
				}
				return list;
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to read SLS_CUSTOM_LOOT: " + ex.Message);
				return null;
			}
		}
	}
	public static class NemesisSystemData
	{
		public static DataObjects.NemesisConfiguration SLE_Nemesis_Settings = DefaultConfiguration;

		public static readonly DataObjects.NemesisConfiguration DefaultConfiguration = new DataObjects.NemesisConfiguration
		{
			NemesisVersion = 5,
			NemesisActionCooldownSeconds = 10f,
			NemesisInfluenceRadius = 300f,
			NemesisMinSpawnDistance = 30f,
			ScoreSystem = new DataObjects.NemesisScore
			{
				MaxScore = 10000f,
				NeutralScore = 5000f,
				MinScore = 0f,
				ScoreIntervalSeconds = 30f,
				DecayPerUpdate = 250f,
				NearbyAveragingWeight = 0.05f,
				NearbyPlayerRadius = 60f,
				BossKillBonus = 500f,
				BossKillRadius = 100f,
				MeleeDamageDealtFactor = 0.75f,
				RangedDamageDealtFactor = 0.25f,
				MagicDamageDealtFactor = 0.5f,
				DamageTakenFactor = -0.5f,
				DeathScoreReduction = 1500f
			},
			GaurenteedChanges = new DataObjects.NemesisGaurenteedChanges
			{
				FirstBossSetLevel = false,
				FirstBossLevel = 1
			},
			ChanceChanges = new DataObjects.NemesisChanceChanges
			{
				CreatureOps = new Dictionary<string, DataObjects.NemesisChanceEntry>
				{
					{
						"Ocean Serpent Attack",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.3f,
							AllowedBiomes = new List<Biome> { (Biome)256 },
							RequiredGlobalKeys = new List<string> { "defeated_gdking" },
							Action = DataObjects.NemesisAction.Spawn,
							ScoreChange = -1000f,
							ScoreThreshold = 7000f,
							ExtraCooldownSeconds = 300f,
							PlayerReqs = new DataObjects.NemesisPlayerStateRequirements
							{
								PlayerCurrentBiome = (Biome)256,
								MinBiomeHistory = 2
							},
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Serpent",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)6,
									SpawnGroupSize = 1
								}
							}
						}
					},
					{
						"Ocean Serpent Ambush",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.3f,
							AllowedBiomes = new List<Biome> { (Biome)256 },
							RequiredGlobalKeys = new List<string> { "defeated_bonemass" },
							Action = DataObjects.NemesisAction.Spawn,
							ScoreChange = -1000f,
							ScoreThreshold = 7000f,
							ExtraCooldownSeconds = 300f,
							PlayerReqs = new DataObjects.NemesisPlayerStateRequirements
							{
								PlayerCurrentBiome = (Biome)256,
								MinBiomeHistory = 5
							},
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Serpent",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)6,
									SpawnGroupSize = 2
								}
							}
						}
					},
					{
						"TreasureTrolls",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.1f,
							AllowedBiomes = new List<Biome> { (Biome)512 },
							RequiredGlobalKeys = new List<string> { "defeated_goblinking" },
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -100f,
							ExtraCooldownSeconds = 60f,
							PlayerReqs = new DataObjects.NemesisPlayerStateRequirements
							{
								PlayerCurrentBiome = (Biome)16,
								MinBiomeHistory = 3
							},
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Troll",
									CreatureAI = DataObjects.AI.Alerted,
									Faction = (Faction)8,
									SpawnGroupSize = 3,
									CustomName = "Treasure Troll",
									CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
									{
										DataObjects.CreatureBaseAttribute.Size,
										0.3f
									} },
									CustomLoot = new List<DataObjects.ExtendedCharacterDrop>
									{
										new DataObjects.ExtendedCharacterDrop
										{
											Drop = new DataObjects.Drop
											{
												DontScale = true,
												Min = 250,
												Max = 750,
												Prefab = "Coins",
												Chance = 100f
											}
										},
										new DataObjects.ExtendedCharacterDrop
										{
											Drop = new DataObjects.Drop
											{
												DontScale = true,
												Min = 10,
												Max = 15,
												Prefab = "Ruby",
												Chance = 25f
											}
										},
										new DataObjects.ExtendedCharacterDrop
										{
											Drop = new DataObjects.Drop
											{
												DontScale = true,
												Min = 15,
												Max = 20,
												Prefab = "Amber",
												Chance = 25f
											}
										}
									}
								}
							}
						}
					},
					{
						"MistlandHunters",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.5f,
							AllowedBiomes = new List<Biome> { (Biome)512 },
							NotRequiredGlobalKeys = new List<string> { "defeated_dragon", "defeated_goblinking", "defeated_queen", "defeated_fader" },
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -100f,
							ExtraCooldownSeconds = 60f,
							PlayerReqs = new DataObjects.NemesisPlayerStateRequirements
							{
								PlayerCurrentBiome = (Biome)512,
								MinBiomeHistory = 3
							},
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Seeker",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)9,
									SpawnGroupSize = 3
								}
							}
						}
					},
					{
						"PlainsDefenders",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.5f,
							AllowedBiomes = new List<Biome> { (Biome)16 },
							NotRequiredGlobalKeys = new List<string> { "defeated_bonemass", "defeated_dragon", "defeated_goblinking", "defeated_queen", "defeated_fader" },
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -100f,
							ExtraCooldownSeconds = 60f,
							PlayerReqs = new DataObjects.NemesisPlayerStateRequirements
							{
								PlayerCurrentBiome = (Biome)16,
								MinBiomeHistory = 2
							},
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Goblin",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)7,
									SpawnGroupSize = 6
								}
							}
						}
					},
					{
						"MountainDefenders",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.5f,
							AllowedBiomes = new List<Biome> { (Biome)4 },
							NotRequiredGlobalKeys = new List<string> { "defeated_gdking", "defeated_bonemass", "defeated_dragon", "defeated_goblinking", "defeated_queen", "defeated_fader" },
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -100f,
							ExtraCooldownSeconds = 60f,
							PlayerReqs = new DataObjects.NemesisPlayerStateRequirements
							{
								PlayerCurrentBiome = (Biome)4,
								MinBiomeHistory = 2
							},
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Hatchling",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)5,
									SpawnGroupSize = 4
								}
							}
						}
					},
					{
						"CharredAttack",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.3f,
							DeniedBiomes = new List<Biome>
							{
								(Biome)64,
								(Biome)256
							},
							RequiredGlobalKeys = new List<string> { "defeated_fader" },
							ScoreThreshold = 9000f,
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -2000f,
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Charred_Melee",
									CreatureAI = DataObjects.AI.HuntPlayer,
									SpawnGroupSize = 1,
									RequiredModifiers = new Dictionary<string, DataObjects.ModifierType> { 
									{
										"Fire",
										DataObjects.ModifierType.Major
									} }
								},
								new DataObjects.NemesisSpawn
								{
									Prefab = "Charred_Ranged",
									CreatureAI = DataObjects.AI.HuntPlayer,
									SpawnGroupSize = 2,
									RequiredModifiers = new Dictionary<string, DataObjects.ModifierType> { 
									{
										"Fire",
										DataObjects.ModifierType.Major
									} }
								}
							}
						}
					},
					{
						"SeekerAttack",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.3f,
							DeniedBiomes = new List<Biome>
							{
								(Biome)32,
								(Biome)64,
								(Biome)256
							},
							RequiredGlobalKeys = new List<string> { "defeated_queen" },
							ScoreThreshold = 9000f,
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -2000f,
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Seeker",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)9,
									SpawnGroupSize = 3,
									RequiredModifiers = new Dictionary<string, DataObjects.ModifierType> { 
									{
										"Lightning",
										DataObjects.ModifierType.Major
									} }
								}
							}
						}
					},
					{
						"GoblinAttack",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.3f,
							DeniedBiomes = new List<Biome>
							{
								(Biome)32,
								(Biome)64,
								(Biome)256
							},
							RequiredGlobalKeys = new List<string> { "defeated_goblinking" },
							ScoreThreshold = 9000f,
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -2000f,
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Goblin",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)7,
									SpawnGroupSize = 3,
									RequiredModifiers = new Dictionary<string, DataObjects.ModifierType> { 
									{
										"Fire",
										DataObjects.ModifierType.Major
									} }
								},
								new DataObjects.NemesisSpawn
								{
									Prefab = "GoblinShaman",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)7,
									SpawnGroupSize = 1,
									RequiredModifiers = new Dictionary<string, DataObjects.ModifierType> { 
									{
										"Lightning",
										DataObjects.ModifierType.Major
									} }
								}
							}
						}
					},
					{
						"FenringAttack",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.3f,
							DeniedBiomes = new List<Biome>
							{
								(Biome)512,
								(Biome)32,
								(Biome)64,
								(Biome)256
							},
							RequiredGlobalKeys = new List<string> { "defeated_dragon" },
							ScoreThreshold = 9000f,
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -2000f,
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Fenring",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)5,
									SpawnGroupSize = 2,
									RequiredModifiers = new Dictionary<string, DataObjects.ModifierType> { 
									{
										"Big",
										DataObjects.ModifierType.Major
									} }
								}
							}
						}
					},
					{
						"SwampAttack",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.3f,
							DeniedBiomes = new List<Biome>
							{
								(Biome)16,
								(Biome)512,
								(Biome)32,
								(Biome)64,
								(Biome)256
							},
							RequiredGlobalKeys = new List<string> { "defeated_bonemass" },
							ScoreThreshold = 9000f,
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -2000f,
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Draugr_Elite",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)3,
									SpawnGroupSize = 2,
									RequiredModifiers = new Dictionary<string, DataObjects.ModifierType> { 
									{
										"Poison",
										DataObjects.ModifierType.Major
									} }
								}
							}
						}
					},
					{
						"BlackForestSwarm",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.3f,
							DeniedBiomes = new List<Biome>
							{
								(Biome)4,
								(Biome)16,
								(Biome)512,
								(Biome)32,
								(Biome)64,
								(Biome)256
							},
							RequiredGlobalKeys = new List<string> { "defeated_gdking" },
							ScoreThreshold = 9000f,
							Action = DataObjects.NemesisAction.Spawn,
							LevelBonus = 5,
							ScoreChange = -2000f,
							SpawnConfig = new List<DataObjects.NemesisSpawn>
							{
								new DataObjects.NemesisSpawn
								{
									Prefab = "Greydwarf",
									CreatureAI = DataObjects.AI.HuntPlayer,
									Faction = (Faction)2,
									SpawnGroupSize = 6,
									RequiredModifiers = new Dictionary<string, DataObjects.ModifierType> { 
									{
										"FireNova",
										DataObjects.ModifierType.Minor
									} }
								}
							}
						}
					},
					{
						"ReduceCreatureLevel",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.25f,
							ScoreThreshold = 4000f,
							Action = DataObjects.NemesisAction.ChangeLevel,
							LevelBonus = -1,
							ScoreChange = 200f
						}
					},
					{
						"SignificantlyReduceCreatureLevel",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.5f,
							ScoreThreshold = 2000f,
							Action = DataObjects.NemesisAction.ChangeLevel,
							LevelBonus = -3,
							ScoreChange = 400f
						}
					},
					{
						"IncreaseCreatureLevel",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.25f,
							ScoreThreshold = 6000f,
							Action = DataObjects.NemesisAction.ChangeLevel,
							LevelBonus = 1,
							ScoreChange = -250f
						}
					},
					{
						"SignificantlyIncreaseCreatureLevel",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.5f,
							ScoreThreshold = 8000f,
							Action = DataObjects.NemesisAction.ChangeLevel,
							LevelBonus = 3,
							ScoreChange = -500f
						}
					},
					{
						"NemesisMiniboss1",
						new DataObjects.NemesisChanceEntry
						{
							Enabled = true,
							Chance = 0.05f,
							ScoreThreshold = 9500f,
							Action = DataObjects.NemesisAction.SpawnMiniboss,
							LevelBonus = 7,
							ScoreChange = -3000f
						}
					}
				}
			},
			AvailableMiniBosses = new List<DataObjects.NemesisMiniboss>(),
			NemesisMinionTemplatesByBiome = new Dictionary<Biome, List<DataObjects.NemesisMinion>>
			{
				{
					(Biome)1,
					new List<DataObjects.NemesisMinion>
					{
						new DataObjects.NemesisMinion
						{
							PrefabName = "Neck",
							MinAmount = 6,
							MaxAmount = 9,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Boar",
							MinAmount = 3,
							MaxAmount = 6,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Greyling",
							MinAmount = 2,
							MaxAmount = 5,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						}
					}
				},
				{
					(Biome)8,
					new List<DataObjects.NemesisMinion>
					{
						new DataObjects.NemesisMinion
						{
							PrefabName = "GreyDwarf",
							MinAmount = 6,
							MaxAmount = 12,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "GreyDwarfShaman",
							MinAmount = 2,
							MaxAmount = 4,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Skeleton",
							MinAmount = 4,
							MaxAmount = 10,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "SkeletonArcher",
							MinAmount = 3,
							MaxAmount = 6,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						}
					}
				},
				{
					(Biome)2,
					new List<DataObjects.NemesisMinion>
					{
						new DataObjects.NemesisMinion
						{
							PrefabName = "Surtling",
							MinAmount = 6,
							MaxAmount = 12,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Draugr",
							MinAmount = 4,
							MaxAmount = 8,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Draugr_Ranged",
							MinAmount = 3,
							MaxAmount = 6,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Blob",
							MinAmount = 6,
							MaxAmount = 10,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						}
					}
				},
				{
					(Biome)4,
					new List<DataObjects.NemesisMinion>
					{
						new DataObjects.NemesisMinion
						{
							PrefabName = "Wolf",
							MinAmount = 4,
							MaxAmount = 8,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Ulv",
							MinAmount = 4,
							MaxAmount = 8,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Bat",
							MinAmount = 8,
							MaxAmount = 20,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Hatchling",
							MinAmount = 2,
							MaxAmount = 4,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						}
					}
				},
				{
					(Biome)16,
					new List<DataObjects.NemesisMinion>
					{
						new DataObjects.NemesisMinion
						{
							PrefabName = "Deathsquito",
							MinAmount = 4,
							MaxAmount = 8,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								3f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Fuling",
							MinAmount = 6,
							MaxAmount = 12,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "FulingArcher",
							MinAmount = 5,
							MaxAmount = 9,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "FulingShaman",
							MinAmount = 2,
							MaxAmount = 4,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						}
					}
				},
				{
					(Biome)512,
					new List<DataObjects.NemesisMinion>
					{
						new DataObjects.NemesisMinion
						{
							PrefabName = "Seeker",
							MinAmount = 4,
							MaxAmount = 7,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "DvergerRouge",
							MinAmount = 3,
							MaxAmount = 6,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "DvergerMage",
							MinAmount = 2,
							MaxAmount = 5,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Gjall",
							MinAmount = 2,
							MaxAmount = 4,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						}
					}
				},
				{
					(Biome)32,
					new List<DataObjects.NemesisMinion>
					{
						new DataObjects.NemesisMinion
						{
							PrefabName = "Charred_Archer",
							MinAmount = 3,
							MaxAmount = 6,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Charred_Twitcher",
							MinAmount = 6,
							MaxAmount = 10,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Charred_Mage",
							MinAmount = 1,
							MaxAmount = 3,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						},
						new DataObjects.NemesisMinion
						{
							PrefabName = "Charred_Melee",
							MinAmount = 3,
							MaxAmount = 5,
							CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float> { 
							{
								DataObjects.CreatureBaseAttribute.BaseHealth,
								2f
							} },
							CreaturePerLevelValueModifiers = new Dictionary<DataObjects.CreaturePerLevelAttribute, float> { 
							{
								DataObjects.CreaturePerLevelAttribute.DamagePerLevel,
								0.01f
							} }
						}
					}
				}
			},
			RemoteSpawning = new DataObjects.RemoteNemesisSpawnSettings
			{
				Enabled = true,
				CheckIntervalMinutes = 30f,
				MaxSpawnsPerInterval = 3,
				MaxConcurrentTotal = 10,
				ShowMapPin = true,
				MapPinAreaRadius = 60f,
				MapPinSpriteAsset = "",
				FallbackPinType = (PinType)9,
				PinShowsBossName = true,
				TargetPerBiome = new Dictionary<Biome, int>
				{
					{
						(Biome)1,
						1
					},
					{
						(Biome)8,
						1
					},
					{
						(Biome)2,
						1
					},
					{
						(Biome)4,
						1
					},
					{
						(Biome)16,
						1
					},
					{
						(Biome)512,
						1
					},
					{
						(Biome)32,
						1
					}
				},
				MaxConcurrentPerBiome = new Dictionary<Biome, int>
				{
					{
						(Biome)1,
						2
					},
					{
						(Biome)8,
						2
					},
					{
						(Biome)2,
						2
					},
					{
						(Biome)4,
						2
					},
					{
						(Biome)16,
						2
					},
					{
						(Biome)512,
						2
					},
					{
						(Biome)32,
						2
					}
				},
				BiomeRadiusRanges = new Dictionary<Biome, DataObjects.BiomeSpawnRadius>
				{
					{
						(Biome)1,
						new DataObjects.BiomeSpawnRadius
						{
							Min = 500f,
							Max = 3000f
						}
					},
					{
						(Biome)8,
						new DataObjects.BiomeSpawnRadius
						{
							Min = 600f,
							Max = 4000f
						}
					},
					{
						(Biome)2,
						new DataObjects.BiomeSpawnRadius
						{
							Min = 1000f,
							Max = 5000f
						}
					},
					{
						(Biome)4,
						new DataObjects.BiomeSpawnRadius
						{
							Min = 1000f,
							Max = 6000f
						}
					},
					{
						(Biome)16,
						new DataObjects.BiomeSpawnRadius
						{
							Min = 2000f,
							Max = 7000f
						}
					},
					{
						(Biome)512,
						new DataObjects.BiomeSpawnRadius
						{
							Min = 3000f,
							Max = 8000f
						}
					},
					{
						(Biome)32,
						new DataObjects.BiomeSpawnRadius
						{
							Min = 8000f,
							Max = 10000f
						}
					}
				},
				BossCandidatesByBiome = new Dictionary<Biome, List<DataObjects.NemesisSpawn>>
				{
					{
						(Biome)1,
						new List<DataObjects.NemesisSpawn>
						{
							new DataObjects.NemesisSpawn
							{
								Prefab = "Boar",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 8,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Neck",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 3,
										MaxLevel = 9,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Greyling",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 7,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							}
						}
					},
					{
						(Biome)8,
						new List<DataObjects.NemesisSpawn>
						{
							new DataObjects.NemesisSpawn
							{
								Prefab = "Greydwarf",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 3,
										MaxLevel = 10,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Skeleton",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 4,
										MaxLevel = 11,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Troll",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 3,
										MaxLevel = 8,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										2f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							}
						}
					},
					{
						(Biome)2,
						new List<DataObjects.NemesisSpawn>
						{
							new DataObjects.NemesisSpawn
							{
								Prefab = "DraugrElite",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 4,
										MaxLevel = 11,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Wraith",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 4,
										MaxLevel = 11,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Abomination",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 4,
										MaxLevel = 8,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							}
						}
					},
					{
						(Biome)4,
						new List<DataObjects.NemesisSpawn>
						{
							new DataObjects.NemesisSpawn
							{
								Prefab = "Fenring",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 5,
										MaxLevel = 10,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Fenring_Cultist",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 5,
										MaxLevel = 10,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										2f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "StoneGolem",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 5,
										MaxLevel = 10,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										2f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							}
						}
					},
					{
						(Biome)16,
						new List<DataObjects.NemesisSpawn>
						{
							new DataObjects.NemesisSpawn
							{
								Prefab = "GoblinBrute",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 6,
										MaxLevel = 11,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										2f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Unbjorn",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 6,
										MaxLevel = 11,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										2f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Deathsquito",
								SelectionWeight = 0.1f,
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 6,
										MaxLevel = 11,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										10f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							}
						}
					},
					{
						(Biome)512,
						new List<DataObjects.NemesisSpawn>
						{
							new DataObjects.NemesisSpawn
							{
								Prefab = "SeekerBrute",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 7,
										MaxLevel = 12,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										2f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Gjall",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 7,
										MaxLevel = 14,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										2f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Dverger",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 7,
										MaxLevel = 14,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							}
						}
					},
					{
						(Biome)32,
						new List<DataObjects.NemesisSpawn>
						{
							new DataObjects.NemesisSpawn
							{
								Prefab = "Charred_Melee",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 8,
										MaxLevel = 16,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "Charred_Mage",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 8,
										MaxLevel = 16,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "FallenValkyrie",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 8,
										MaxLevel = 16,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										2f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							}
						}
					},
					{
						(Biome)256,
						new List<DataObjects.NemesisSpawn>
						{
							new DataObjects.NemesisSpawn
							{
								Prefab = "Serpent",
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 16,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							},
							new DataObjects.NemesisSpawn
							{
								Prefab = "BonemawSerpent",
								SelectionWeight = 0.1f,
								IsBoss = true,
								Faction = (Faction)8,
								CreatureAI = DataObjects.AI.Alerted,
								LevelupGenerators = new List<DataObjects.LevelGenerator>
								{
									new DataObjects.LevelGenerator
									{
										MinLevel = 2,
										MaxLevel = 16,
										LevelUpChance = 0.3f
									}
								},
								CreatureBaseValueModifiers = new Dictionary<DataObjects.CreatureBaseAttribute, float>
								{
									{
										DataObjects.CreatureBaseAttribute.BaseHealth,
										4f
									},
									{
										DataObjects.CreatureBaseAttribute.BaseDamage,
										1.5f
									}
								}
							}
						}
					}
				}
			},
			NemesisBossLootTables = new Dictionary<Biome, List<DataObjects.ExtendedCharacterDrop>>
			{
				{
					(Biome)1,
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 50,
								Max = 150,
								Prefab = "Coins",
								Chance = 100f
							}
						}
					}
				},
				{
					(Biome)8,
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 100,
								Max = 250,
								Prefab = "Coins",
								Chance = 100f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "Amber",
								Chance = 25f
							}
						}
					}
				},
				{
					(Biome)2,
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 150,
								Max = 300,
								Prefab = "Coins",
								Chance = 100f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "Ruby",
								Chance = 15f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "Amber",
								Chance = 25f
							}
						}
					}
				},
				{
					(Biome)4,
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 200,
								Max = 350,
								Prefab = "Coins",
								Chance = 100f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "Amber",
								Chance = 25f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "Ruby",
								Chance = 15f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "AmberPearl",
								Chance = 10f
							}
						}
					}
				},
				{
					(Biome)16,
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 250,
								Max = 400,
								Prefab = "Coins",
								Chance = 100f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 5,
								Max = 10,
								Prefab = "Amber",
								Chance = 50f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "Ruby",
								Chance = 15f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "AmberPearl",
								Chance = 25f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 1,
								Prefab = "SilverNecklace",
								Chance = 5f
							}
						}
					}
				},
				{
					(Biome)512,
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 300,
								Max = 500,
								Prefab = "Coins",
								Chance = 100f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 5,
								Max = 10,
								Prefab = "Amber",
								Chance = 50f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "Ruby",
								Chance = 15f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "AmberPearl",
								Chance = 25f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 1,
								Prefab = "SilverNecklace",
								Chance = 10f
							}
						}
					}
				},
				{
					(Biome)32,
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 400,
								Max = 600,
								Prefab = "Coins",
								Chance = 100f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 5,
								Max = 10,
								Prefab = "Amber",
								Chance = 60f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "Ruby",
								Chance = 25f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "AmberPearl",
								Chance = 35f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 1,
								Prefab = "SilverNecklace",
								Chance = 15f
							}
						}
					}
				},
				{
					(Biome)256,
					new List<DataObjects.ExtendedCharacterDrop>
					{
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 500,
								Max = 800,
								Prefab = "Coins",
								Chance = 100f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 5,
								Max = 10,
								Prefab = "Amber",
								Chance = 75f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "Ruby",
								Chance = 50f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 3,
								Prefab = "AmberPearl",
								Chance = 30f
							}
						},
						new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								DontScale = true,
								Min = 1,
								Max = 1,
								Prefab = "SilverNecklace",
								Chance = 25f
							}
						}
					}
				}
			}
		};

		internal static void Init()
		{
			SLE_Nemesis_Settings = DefaultConfiguration;
			try
			{
				if (File.Exists(ValConfig.nemesisFilePath))
				{
					UpdateYamlConfig(File.ReadAllText(ValConfig.nemesisFilePath));
				}
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"There was an error updating the Nemesis values, defaults will be used. Exception: {arg}");
			}
		}

		public static string YamlDefaultConfig()
		{
			return DataObjects.yamlSerializer.Serialize((object)DefaultConfiguration);
		}

		internal static void UpdateNemesisLog(string data)
		{
			Logger.LogNemesis("Updating Nemesis Action Log: " + ValConfig.nemesisLogFilePath);
			ValConfig.GetSavedDataSecondaryConfigDirectoryPath();
			FileInfo fileInfo = new FileInfo(ValConfig.nemesisLogFilePath);
			if (fileInfo.Exists && fileInfo.Length > 1073741824)
			{
				Logger.LogNemesis($"Nemesis log exceeded {1073741824L} bytes, overwriting with most recent event.");
				File.WriteAllText(ValConfig.nemesisLogFilePath, data);
			}
			else
			{
				File.AppendAllText(ValConfig.nemesisLogFilePath, data);
			}
		}

		public static bool UpdateYamlConfig(string yaml)
		{
			try
			{
				Logger.LogNemesis("Loaded new Nemesis settings...");
				SLE_Nemesis_Settings = DataObjects.yamlDeserializer.Deserialize<DataObjects.NemesisConfiguration>(yaml);
				if (SLE_Nemesis_Settings.NemesisVersion != DefaultConfiguration.NemesisVersion)
				{
					Logger.LogInfo("Nemesis Config version outdated, resetting to default.");
					SLE_Nemesis_Settings = DefaultConfiguration;
					File.WriteAllText(ValConfig.nemesisFilePath, YamlDefaultConfig());
				}
			}
			catch (Exception ex)
			{
				StarLevelSystem.Log.LogWarning((object)("Failed to parse NemesisSettings.yaml, defaults will be used. Error: " + ex.Message));
				return false;
			}
			return true;
		}
	}
	public static class RaidsData
	{
		public static DataObjects.RaidConfiguration SLE_Raid_Settings = DefaultConfiguration;

		internal static Dictionary<string, DataObjects.RaidDefinition> RaidsByName = new Dictionary<string, DataObjects.RaidDefinition>();

		public static readonly DataObjects.RaidConfiguration DefaultConfiguration = new DataObjects.RaidConfiguration
		{
			GlobalSettings = new DataObjects.GlobalRaidSettings
			{
				DisableAllRaids = false,
				GlobalRaidIntervalScalar = 1f,
				GlobalRaidChanceScalar = 1f
			},
			Raids = new List<DataObjects.RaidDefinition>
			{
				new DataObjects.RaidDefinition
				{
					Name = "army_eikthyr",
					Duration = 180f,
					StartMessage = "$event_eikthyrarmy_start",
					EndMessage = "$event_eikthyrarmy_end",
					ForceMusic = DataObjects.Music.Zcombat,
					ForceEnvironment = DataObjects.Environment.Misty,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_eikthyr" },
						NotRequiredGlobalKeys = new List<string> { "defeated_gdking" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Greyling",
							MaxSpawned = 20,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 5,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Neck",
							MaxSpawned = 10,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 5,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Boar",
							MaxSpawned = 10,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 5,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "foresttrolls",
					Duration = 180f,
					StartMessage = "$event_foresttrolls_start",
					EndMessage = "$event_foresttrolls_end",
					ForceMusic = DataObjects.Music.Zcombat,
					ForceEnvironment = DataObjects.Environment.DeepForest_Mist,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_eikthyr" },
						NotRequiredGlobalKeys = new List<string> { "defeated_bonemass" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Troll",
							MaxSpawned = 9,
							SpawnInterval = 30f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 3,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 2,
							CustomCreatureLevelUpChance = new SortedDictionary<int, float>
							{
								{ 1, 50f },
								{ 2, 25f },
								{ 3, 20f },
								{ 4, 15f },
								{ 5, 7f },
								{ 6, 3f },
								{ 7, 1f }
							}
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "army_theelder",
					Duration = 180f,
					StartMessage = "$event_gdkingarmy_start",
					EndMessage = "$event_gdkingarmy_end",
					ForceEnvironment = DataObjects.Environment.DeepForest_Mist,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_gdking" },
						NotRequiredGlobalKeys = new List<string> { "defeated_bonemass" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Greydwarf",
							MaxSpawned = 20,
							SpawnInterval = 3f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 5,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Greydwarf_Elite",
							MaxSpawned = 6,
							SpawnInterval = 8f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 5,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Greydwarf_Shaman",
							MaxSpawned = 4,
							SpawnInterval = 8f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 5,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "skeletons",
					Duration = 90f,
					StartMessage = "$event_skeletons_start",
					EndMessage = "$event_skeletons_end",
					ForceEnvironment = DataObjects.Environment.Crypt,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_gdking" },
						NotRequiredGlobalKeys = new List<string> { "defeated_bonemass" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Skeleton",
							MaxSpawned = 20,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							UseRaidLevelSystem = false,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Skeleton_Poison",
							MaxSpawned = 8,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							UseRaidLevelSystem = false,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "blobs",
					Duration = 90f,
					StartMessage = "$event_blobs_start",
					EndMessage = "$event_blobs_over",
					ForceEnvironment = DataObjects.Environment.SwampRain,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_gdking" },
						NotRequiredGlobalKeys = new List<string> { "defeated_bonemass" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Blob",
							MaxSpawned = 20,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 12,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 2
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "BlobElite",
							MaxSpawned = 8,
							SpawnInterval = 8f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 12,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "ghosts",
					Duration = 180f,
					StartMessage = "$event_ghosts_start",
					EndMessage = "$event_ghosts_end",
					ForceEnvironment = DataObjects.Environment.Ghosts,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_bonemass" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Ghost",
							MaxSpawned = 12,
							SpawnInterval = 30f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 16,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Wraith",
							MaxSpawned = 12,
							SpawnInterval = 30f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 16,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "surtlings",
					Duration = 60f,
					StartMessage = "$event_surtlings_start",
					EndMessage = "$event_surtlings_end",
					ForceEnvironment = DataObjects.Environment.Ashlands_CinderRain,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						Biomes = new List<Biome>
						{
							(Biome)2,
							(Biome)1,
							(Biome)8
						},
						NearBaseOnly = true,
						RequiredGlobalKeys = new List<string> { "defeated_gdking" },
						NotRequiredGlobalKeys = new List<string> { "defeated_bonemass" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Surtling",
							MaxSpawned = 40,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							UseRaidLevelSystem = false,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 2,
							RequiredModifiers = new Dictionary<string, DataObjects.ModifierType> { 
							{
								"Fire",
								DataObjects.ModifierType.Major
							} }
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "army_bonemass",
					Duration = 180f,
					StartMessage = "$event_bonemassarmy_start",
					EndMessage = "$event_bonemassarmy_end",
					ForceMusic = DataObjects.Music.Zcombat,
					ForceEnvironment = DataObjects.Environment.SwampRain,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_bonemass" },
						NotRequiredGlobalKeys = new List<string> { "defeated_dragon" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Skeleton",
							MaxSpawned = 30,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 12,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 2
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Blob",
							MaxSpawned = 10,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 12,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Draugr",
							MaxSpawned = 12,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 12,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 2
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Draugr_Elite",
							MaxSpawned = 4,
							SpawnInterval = 10f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 12,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Draugr_Ranged",
							MaxSpawned = 8,
							SpawnInterval = 8f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 12,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "wolves",
					Duration = 60f,
					StartMessage = "$event_wolves_start",
					EndMessage = "$event_wolves_end",
					ForceMusic = DataObjects.Music.Zcombat,
					ForceEnvironment = DataObjects.Environment.SnowStorm,
					Activation = new DataObjects.RaidActivation
					{
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_bonemass" },
						NotRequiredGlobalKeys = new List<string> { "defeated_dragon" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Wolf",
							MaxSpawned = 20,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 16,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Fenring",
							MaxSpawned = 8,
							SpawnInterval = 12f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 16,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "cultists",
					Duration = 180f,
					StartMessage = "$event_caves_start",
					EndMessage = "$event_caves_end",
					ForceMusic = DataObjects.Music.Zcombat,
					ForceEnvironment = DataObjects.Environment.SnowStorm,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_dragon" },
						NotRequiredGlobalKeys = new List<string> { "defeated_queen" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Ulv",
							MaxSpawned = 20,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 20,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Fenring_Cultist",
							MaxSpawned = 6,
							SpawnInterval = 12f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 20,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "army_moder",
					Duration = 180f,
					StartMessage = "$event_moderarmy_start",
					EndMessage = "$event_moderarmy_end",
					ForceMusic = DataObjects.Music.Zcombat,
					ForceEnvironment = DataObjects.Environment.Twilight_Snow,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_dragon" },
						NotRequiredGlobalKeys = new List<string> { "defeated_goblinking" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Hatchling",
							MaxSpawned = 12,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 16,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 2
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Wolf",
							MaxSpawned = 12,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 16,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Fenring_Cultist",
							MaxSpawned = 6,
							SpawnInterval = 12f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 16,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "army_goblin",
					Duration = 180f,
					StartMessage = "$event_goblinarmy_start",
					EndMessage = "$event_goblinarmy_end",
					ForceEnvironment = DataObjects.Environment.GoblinKing,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_goblinking" },
						NotRequiredGlobalKeys = new List<string> { "defeated_queen" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Goblin",
							MaxSpawned = 16,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 20,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 2
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "GoblinArcher",
							MaxSpawned = 12,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 20,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "GoblinShaman",
							MaxSpawned = 4,
							SpawnInterval = 10f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 20,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "GoblinBrute",
							MaxSpawned = 2,
							SpawnInterval = 12f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 20,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "bats",
					Duration = 60f,
					StartMessage = "$event_bats_start",
					EndMessage = "$event_bats_end",
					ForceEnvironment = DataObjects.Environment.GoblinKing,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_goblinking" },
						NotRequiredGlobalKeys = new List<string> { "defeated_queen" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Bat",
							MaxSpawned = 20,
							SpawnInterval = 3f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "gjall_ambush",
					Duration = 90f,
					StartMessage = "$event_gjallarmy_start",
					EndMessage = "$event_gjallarmy_end",
					ForceMusic = DataObjects.Music.Zcombat,
					ForceEnvironment = DataObjects.Environment.Mistlands_thunder,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_queen" },
						NotRequiredGlobalKeys = new List<string> { "defeated_fader" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Gjall",
							MaxSpawned = 4,
							SpawnInterval = 12f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 26,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Tick",
							MaxSpawned = 16,
							SpawnInterval = 8f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 26,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 2,
							ModifiersNotAllowed = new List<string> { "FireNova" }
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "army_seekers",
					Duration = 180f,
					StartMessage = "$event_seekerarmy_start",
					EndMessage = "$event_seekerarmy_end",
					ForceEnvironment = DataObjects.Environment.Mistlands_thunder,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_queen" },
						NotRequiredGlobalKeys = new List<string> { "defeated_fader" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Seeker",
							MaxSpawned = 12,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 26,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "SeekerBrute",
							MaxSpawned = 2,
							SpawnInterval = 12f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 26,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Tick",
							MaxSpawned = 6,
							SpawnInterval = 8f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 26,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "army_charred",
					Duration = 180f,
					StartMessage = "$event_charredarmy_start",
					EndMessage = "$event_charredarmy_end",
					ForceEnvironment = DataObjects.Environment.Ashlands_storm,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_queen" },
						NotRequiredGlobalKeys = new List<string> { "defeated_fader" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Charred_Twitcher",
							MaxSpawned = 16,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Charred_Archer",
							MaxSpawned = 6,
							SpawnInterval = 12f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Charred_Melee",
							MaxSpawned = 4,
							SpawnInterval = 8f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "army_charred_spawners",
					Duration = 90f,
					StartMessage = "event_charredspawnerarmy_start",
					EndMessage = "event_charrespawnerarmy_end",
					ForceEnvironment = DataObjects.Environment.Ashlands_ashrain,
					ForceMusic = DataObjects.Music.Zcombat,
					Activation = new DataObjects.RaidActivation
					{
						NearBaseOnly = true,
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "defeated_queen" },
						NotRequiredGlobalKeys = new List<string> { "defeated_fader" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Spawner_CharredStone",
							MaxSpawned = 4,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "hildir_boss_revenge1",
					Duration = 180f,
					StartMessage = "$event_hildirboss1_start",
					EndMessage = "$event_hildirboss1_end",
					ForceMusic = DataObjects.Music.ZCombatEventL2,
					ForceEnvironment = DataObjects.Environment.Ashlands_ashrain,
					Activation = new DataObjects.RaidActivation
					{
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "hildir1" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Skeleton_Hildir",
							MaxSpawned = 1,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Skeleton",
							MaxSpawned = 16,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Skeleton_Poison",
							MaxSpawned = 6,
							SpawnInterval = 10f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "hildir_boss_revenge2",
					Duration = 180f,
					StartMessage = "$event_hildirboss2_start",
					EndMessage = "$event_hildirboss2_end",
					ForceMusic = DataObjects.Music.ZCombatEventL3,
					ForceEnvironment = DataObjects.Environment.Twilight_SnowStorm,
					Activation = new DataObjects.RaidActivation
					{
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "hildir2" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Fenring_Cultist_Hildir",
							MaxSpawned = 1,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Ulv",
							MaxSpawned = 16,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Fenring_Cultist",
							MaxSpawned = 4,
							SpawnInterval = 10f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "hildir_boss_revenge3",
					Duration = 180f,
					StartMessage = "$event_hildirboss3_start",
					EndMessage = "$event_hildirboss3_end",
					ForceMusic = DataObjects.Music.ZCombatEventL4,
					ForceEnvironment = DataObjects.Environment.GoblinKing,
					Activation = new DataObjects.RaidActivation
					{
						Chance = 50f,
						RequiredGlobalKeys = new List<string> { "hildir3" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "GoblinBruteBros",
							MaxSpawned = 1,
							SpawnInterval = 4f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Goblin",
							MaxSpawned = 16,
							SpawnInterval = 6f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							SpawnGroupSize = 3
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "GoblinShaman",
							MaxSpawned = 2,
							SpawnInterval = 10f,
							SpawnChance = 100f,
							LevelMin = 1,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer
						}
					}
				},
				new DataObjects.RaidDefinition
				{
					Name = "deathlink_surprise",
					Duration = 180f,
					StartMessage = "$SLS_Secret_event1_start",
					EndMessage = "$SLS_Secret_event1_end",
					ForceEnvironment = DataObjects.Environment.Mistlands_thunder,
					ForceMusic = DataObjects.Music.ZCombatEventL4,
					Activation = new DataObjects.RaidActivation
					{
						Chance = 25f,
						RequiredGlobalKeys = new List<string> { "defeated_fader" },
						RequiredPlayerKeys = new List<string> { "Deathlink" }
					},
					Spawns = new List<DataObjects.RaidSpawnEntry>
					{
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "GoblinBruteBros",
							MaxSpawned = 1,
							SpawnInterval = 180f,
							SpawnChance = 100f,
							LevelMin = 15,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							Faction = (Faction)4
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Fenring_Cultist_Hildir",
							MaxSpawned = 1,
							SpawnInterval = 180f,
							SpawnChance = 100f,
							LevelMin = 20,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							Faction = (Faction)4
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Skeleton_Hildir",
							MaxSpawned = 1,
							SpawnInterval = 180f,
							SpawnChance = 100f,
							LevelMin = 25,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							Faction = (Faction)4
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "Skeleton_Poison",
							MaxSpawned = 8,
							SpawnInterval = 10f,
							SpawnChance = 100f,
							LevelMin = 20,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							Faction = (Faction)4
						},
						new DataObjects.RaidSpawnEntry
						{
							PrefabName = "GoblinShaman",
							MaxSpawned = 2,
							SpawnInterval = 10f,
							SpawnChance = 100f,
							LevelMin = 12,
							LevelMax = 30,
							CreatureAI = DataObjects.AI.HuntPlayer,
							Faction = (Faction)4
						}
					}
				}
			}
		};

		internal static void SaveServerRaidData(string data)
		{
			ValConfig.GetSavedDataSecondaryConfigDirectoryPath();
			File.WriteAllText(ValConfig.raidsServerSavedData, data);
		}

		internal static string LoadServerRaidData()
		{
			ValConfig.GetSavedDataSecondaryConfigDirectoryPath();
			if (File.Exists(ValConfig.raidsServerSavedData))
			{
				return File.ReadAllText(ValConfig.raidsServerSavedData);
			}
			return "";
		}

		internal static void Init()
		{
			SLE_Raid_Settings = DefaultConfiguration;
			try
			{
				if (File.Exists(ValConfig.raidsFilePath))
				{
					UpdateYamlConfig(File.ReadAllText(ValConfig.raidsFilePath));
					return;
				}
				SaveServerRaidData(DataObjects.yamlSerializer.Serialize((object)RaidControl.ServerPlayerRaidData));
				UpdateYamlConfig(File.ReadAllText(ValConfig.raidsFilePath));
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"There was an error updating the Raid values, defaults will be used. Exception: {arg}");
			}
		}

		public static string YamlDefaultConfig()
		{
			return DataObjects.yamlSerializer.Serialize((object)DefaultConfiguration);
		}

		public static bool UpdateYamlConfig(string yaml)
		{
			try
			{
				Logger.LogDebug("Loaded new Raid settings...");
				SLE_Raid_Settings = DataObjects.yamlDeserializer.Deserialize<DataObjects.RaidConfiguration>(yaml);
				RaidsByName.Clear();
				foreach (DataObjects.RaidDefinition raid in SLE_Raid_Settings.Raids)
				{
					if (RaidsByName.ContainsKey(raid.Name))
					{
						Logger.LogWarning("Raid with duplicate name, will be skipped. (" + raid.Name + ")");
					}
					RaidsByName.Add(raid.Name, raid);
				}
				RaidControl.ApplyRaidConfiguration(RandEventSystem.instance);
			}
			catch (Exception ex)
			{
				StarLevelSystem.Log.LogError((object)("Failed to parse RaidSettings YAML: " + ex.Message));
				return false;
			}
			return true;
		}
	}
	internal static class ZoneScaleSystemData
	{
		internal static List<DataObjects.ZoneData> Zones = new List<DataObjects.ZoneData>();

		private const float IndexCellSize = 500f;

		private static Dictionary<long, List<DataObjects.ZoneData>> zoneIndex = new Dictionary<long, List<DataObjects.ZoneData>>();

		private static Dictionary<int, DataObjects.ZoneData> zoneById = new Dictionary<int, DataObjects.ZoneData>();

		private static DataObjects.ZoneData lastZone = null;

		private static readonly Dictionary<int, int> pendingLevelUpdates = new Dictionary<int, int>();

		private static bool zonesDirty = false;

		internal static bool zonesBuilt = false;

		internal static bool buildingZones = false;

		private static bool decayRunning = false;

		internal static bool overlayAvailable = false;

		private const float DecayTickIntervalSeconds = 900f;

		internal static int overlayUpdates = 0;

		private static Coroutine decayCoroutine = null;

		private const int ZoneIdStride = 100000;

		internal static int ZoneIdForCell(int cellX, int cellZ)
		{
			return cellX * 100000 + cellZ;
		}

		internal static int ZoneIdForBounds(float minX, float minZ)
		{
			float value = ValConfig.MaxZoneSize.Value;
			int cellX = Mathf.RoundToInt((minX + 10000f) / value);
			int cellZ = Mathf.RoundToInt((minZ + 10000f) / value);
			return ZoneIdForCell(cellX, cellZ);
		}

		internal static void ApplyDeaths(List<DataObjects.SerializableVector3> deaths)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!zonesBuilt)
			{
				return;
			}
			int value = ValConfig.ZoneKillsPerLevelUp.Value;
			HashSet<DataObjects.ZoneData> hashSet = new HashSet<DataObjects.ZoneData>();
			foreach (DataObjects.SerializableVector3 death in deaths)
			{
				DataObjects.ZoneData zoneForPosition = GetZoneForPosition(death);
				if (zoneForPosition == null)
				{
					continue;
				}
				int num = zoneForPosition.TotalKills++;
				if (value > 0)
				{
					int num2 = zoneForPosition.TotalKills / value - num / value;
					if (num2 > 0)
					{
						zoneForPosition.ZoneLevel += num2;
						zoneForPosition.LastDecayTimestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
						hashSet.Add(zoneForPosition);
					}
				}
			}
			if (deaths.Count > 0)
			{
				zonesDirty = true;
			}
			if (hashSet.Count > 0)
			{
				Logger.LogDebug($"{hashSet.Count} zone(s) leveled up from a batch of {deaths.Count} kills.");
				BroadcastZoneLevels(hashSet);
				ZoneScaleSystem.DrawMinimapOverlay();
			}
		}

		internal static void StartDecayCoroutine()
		{
			if (!decayRunning && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				decayRunning = true;
				decayCoroutine = ((MonoBehaviour)TaskRunner.Run()).StartCoroutine(DecayZoneLevels());
			}
		}

		internal static void ResetState()
		{
			FlushPendingSave();
			if (decayCoroutine != null)
			{
				((MonoBehaviour)TaskRunner.Run()).StopCoroutine(decayCoroutine);
				decayCoroutine = null;
			}
			Zones = new List<DataObjects.ZoneData>();
			zoneIndex = new Dictionary<long, List<DataObjects.ZoneData>>();
			zoneById = new Dictionary<int, DataObjects.ZoneData>();
			pendingLevelUpdates.Clear();
			lastZone = null;
			zonesBuilt = false;
			buildingZones = false;
			overlayAvailable = false;
			decayRunning = false;
			zonesDirty = false;
		}

		private static IEnumerator DecayZoneLevels()
		{
			while (true)
			{
				yield return (object)new WaitForSeconds(900f);
				if (!zonesBuilt || Zones.Count == 0)
				{
					if (zonesDirty)
					{
						SaveZoneData();
						zonesDirty = false;
					}
					continue;
				}
				long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
				float value = ValConfig.ZoneDecayLevelsPerHour.Value;
				if (value <= 0f)
				{
					foreach (DataObjects.ZoneData zone in Zones)
					{
						zone.LastDecayTimestamp = num;
					}
					if (zonesDirty)
					{
						SaveZoneData();
						zonesDirty = false;
					}
					continue;
				}
				List<DataObjects.ZoneData> list = new List<DataObjects.ZoneData>();
				foreach (DataObjects.ZoneData zone2 in Zones)
				{
					if (zone2.ZoneLevel > 1)
					{
						double num2 = ((double)num - zone2.LastDecayTimestamp) / 3600.0 * (double)value;
						if (num2 >= 1.0)
						{
							int num3 = (int)num2;
							zone2.ZoneLevel = Mathf.Max(1, zone2.ZoneLevel - num3);
							zone2.LastDecayTimestamp += (double)((float)num3 / value) * 3600.0;
							list.Add(zone2);
						}
					}
				}
				if (list.Count > 0)
				{
					Logger.LogDebug("Zone levels decayed.");
					zonesDirty = true;
					BroadcastZoneLevels(list);
					ZoneScaleSystem.DrawMinimapOverlay();
				}
				if (zonesDirty)
				{
					SaveZoneData();
					zonesDirty = false;
				}
			}
		}

		internal static DataObjects.ZoneData GetZoneForPosition(Vector3 pos)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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)
			if (lastZone != null && lastZone.ContainsPosition(pos))
			{
				return lastZone;
			}
			if (zoneIndex.TryGetValue(CellKey(pos.x, pos.z), out var value))
			{
				foreach (DataObjects.ZoneData item in value)
				{
					if (item.ContainsPosition(pos))
					{
						lastZone = item;
						return item;
					}
				}
			}
			return null;
		}

		private static long CellKey(float x, float z)
		{
			int num = Mathf.FloorToInt(x / 500f);
			int num2 = Mathf.FloorToInt(z / 500f);
			return (long)(((ulong)(uint)num << 32) | (uint)num2);
		}

		internal static void BuildZoneIndex()
		{
			zoneIndex = new Dictionary<long, List<DataObjects.ZoneData>>();
			zoneById = new Dictionary<int, DataObjects.ZoneData>(Zones.Count);
			lastZone = null;
			foreach (DataObjects.ZoneData zone in Zones)
			{
				zoneById[zone.ZoneId] = zone;
				int num = Mathf.FloorToInt(zone.MinX / 500f);
				int num2 = Mathf.FloorToInt(zone.MaxX / 500f);
				int num3 = Mathf.FloorToInt(zone.MinZ / 500f);
				int num4 = Mathf.FloorToInt(zone.MaxZ / 500f);
				for (int i = num; i <= num2; i++)
				{
					for (int j = num3; j <= num4; j++)
					{
						long key = (long)(((ulong)(uint)i << 32) | (uint)j);
						if (!zoneIndex.TryGetValue(key, out var value))
						{
							value = new List<DataObjects.ZoneData>();
							zoneIndex[key] = value;
						}
						value.Add(zone);
					}
				}
			}
			if (pendingLevelUpdates.Count <= 0)
			{
				return;
			}
			foreach (KeyValuePair<int, int> pendingLevelUpdate in pendingLevelUpdates)
			{
				if (zoneById.TryGetValue(pendingLevelUpdate.Key, out var value2))
				{
					value2.ZoneLevel = pendingLevelUpdate.Value;
				}
			}
			pendingLevelUpdates.Clear();
		}

		internal static void SaveZoneData()
		{
			try
			{
				ValConfig.GetSavedDataSecondaryConfigDirectoryPath();
				DataObjects.ZoneSystemSaveData obj = new DataObjects.ZoneSystemSaveData
				{
					Zones = Zones
				};
				ZNet instance = ZNet.instance;
				obj.WorldName = ((instance != null) ? instance.GetWorldName() : null) ?? "unknown";
				DataObjects.ZoneSystemSaveData zoneSystemSaveData = obj;
				File.WriteAllText(ValConfig.zoneDataSavedDataPath, DataObjects.yamlSerializer.Serialize((object)zoneSystemSaveData));
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to save zone data: " + ex.Message);
			}
		}

		internal static void FlushPendingSave()
		{
			if (zonesDirty && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				SaveZoneData();
				zonesDirty = false;
			}
		}

		internal static bool LoadZoneData()
		{
			try
			{
				ValConfig.GetSavedDataSecondaryConfigDirectoryPath();
				if (!File.Exists(ValConfig.zoneDataSavedDataPath))
				{
					return false;
				}
				string text = File.ReadAllText(ValConfig.zoneDataSavedDataPath);
				DataObjects.ZoneSystemSaveData zoneSystemSaveData = DataObjects.yamlDeserializer.Deserialize<DataObjects.ZoneSystemSaveData>(text);
				if (zoneSystemSaveData?.Zones == null || zoneSystemSaveData.Zones.Count == 0)
				{
					return false;
				}
				ZNet instance = ZNet.instance;
				string text2 = ((instance != null) ? instance.GetWorldName() : null) ?? "";
				if (!string.IsNullOrEmpty(zoneSystemSaveData.WorldName) && zoneSystemSaveData.WorldName != text2)
				{
					Logger.LogInfo("Zone data is for a different world (" + zoneSystemSaveData.WorldName + " vs " + text2 + "), rebuilding.");
					return false;
				}
				Zones = zoneSystemSaveData.Zones;
				foreach (DataObjects.ZoneData zone in Zones)
				{
					zone.ZoneId = ZoneIdForBounds(zone.MinX, zone.MinZ);
				}
				BuildZoneIndex();
				return true;
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to load zone data: " + ex.Message);
				return false;
			}
		}

		internal static ZPackage SerializeDeaths(List<DataObjects.SerializableVector3> deaths)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(DataObjects.yamlSerializerJsonCompat.Serialize((object)deaths));
			return val;
		}

		internal static void BroadcastZoneLevels(ICollection<DataObjects.ZoneData> zones)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && zones.Count != 0 && ZNet.instance.m_peers != null && ZNet.instance.m_peers.Count != 0)
			{
				ValConfig.ZoneLevelSyncRPC.SendPackage(ZNet.instance.m_peers, SerializeZoneLevels(zones));
			}
		}

		private static ZPackage SerializeZoneLevels(ICollection<DataObjects.ZoneData> zones)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(zones.Count);
			foreach (DataObjects.ZoneData zone in zones)
			{
				val.Write(zone.ZoneId);
				val.Write(zone.ZoneLevel);
			}
			return val;
		}

		internal static ZPackage SerializeLeveledZonesForSync()
		{
			return SerializeZoneLevels(Zones.Where((DataObjects.ZoneData z) => z.ZoneLevel > 1).ToList());
		}

		internal static IEnumerator OnClientReceiveZoneLevels(long sender, ZPackage package)
		{
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				int key = package.ReadInt();
				int num2 = package.ReadInt();
				if (zoneById.TryGetValue(key, out var value))
				{
					value.ZoneLevel = num2;
				}
				else
				{
					pendingLevelUpdates[key] = num2;
				}
			}
			if (num > 0 && zonesBuilt)
			{
				ZoneScaleSystem.DrawMinimapOverlay();
			}
			yield return null;
		}
	}
}
namespace StarLevelSystem.common
{
	internal class ValConfig
	{
		public static ConfigFile cfg;

		internal const string LevelSettingsFileName = "LevelSettings.yaml";

		internal const string ColorSettingsFileName = "ColorSettings.yaml";

		internal const string LootSettingsFileName = "LootSettings.yaml";

		internal const string ModifiersFileName = "Modifiers.yaml";

		internal const string RaidSettingsFileName = "RaidSettings.yaml";

		internal const string NemesisSettingsFileName = "NemesisSettings.yaml";

		internal const string StarLevelSystem = "StarLevelSystem";

		internal const string ServerRaidSavedData = "ServerRaidSavedData.yaml";

		internal const string SavedData = "SavedData";

		internal const string NemesisLogFileName = "NemesisLog.log";

		internal static string levelsFilePath = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "LevelSettings.yaml");

		internal static string colorsFilePath = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "ColorSettings.yaml");

		internal static string creatureLootFilePath = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "LootSettings.yaml");

		internal static string creatureModifierFilePath = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "Modifiers.yaml");

		internal static string raidsFilePath = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "RaidSettings.yaml");

		internal static string nemesisFilePath = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "NemesisSettings.yaml");

		internal static string nemesisLogFilePath = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "SavedData", "NemesisLog.log");

		internal static string raidsServerSavedData = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "SavedData", "ServerRaidSavedData.yaml");

		internal const string ZoneDataFileName = "ZoneData.yaml";

		internal static string zoneDataSavedDataPath = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "SavedData", "ZoneData.yaml");

		internal const string NemesisRemoteStateFileName = "NemesisRemoteState.yaml";

		internal static string nemesisRemoteStateFilePath = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "SavedData", "NemesisRemoteState.yaml");

		internal static bool ServerConfigsSynced = false;

		private static CustomRPC LevelSettingsRPC;

		private static CustomRPC ColorSettingsRPC;

		private static CustomRPC CreatureLootSettingsRPC;

		private static CustomRPC ModifiersRPC;

		private static CustomRPC RaidsRPC;

		private static CustomRPC NemesisRPC;

		internal static CustomRPC ClientSendPlayerPrivateKeysRPC;

		internal static CustomRPC ClientStartRaidRPC;

		internal static CustomRPC RaidCommittedRPC;

		internal static CustomRPC ClientForcePlayMusicRPC;

		internal static CustomRPC ClientClearNearbyEventsRPC;

		internal static CustomRPC SendNewNemesisBossRPC;

		internal static CustomRPC RemoveNemesisBossRPC;

		internal static CustomRPC AddNemesisBossPinRPC;

		internal static CustomRPC RemoveNemesisBossPinRPC;

		internal static CustomRPC ReportNemesisBossDeathRPC;

		internal static CustomRPC ClientRequestNemesisRemoteSpawnRPC;

		internal static CustomRPC ClientPlaceNemesisSpawnerRPC;

		internal static CustomRPC ZoneKillReportRPC;

		internal static CustomRPC ZoneLevelSyncRPC;

		public static ConfigEntry<bool> EnableDebugMode;

		public static ConfigEntry<int> MaxLevel;

		public static ConfigEntry<int> MaxBossLevel;

		public static ConfigEntry<bool> OverLevelCreaturesGetRerolledOnLoad;

		public static ConfigEntry<bool> EnableMapRingsForDistanceBonus;

		public static ConfigEntry<bool> MapRingsAboveFog;

		public static ConfigEntry<bool> DistanceBonusIsFromStarterTemple;

		public static ConfigEntry<int> MiniMapRingGeneratorUpdatesPerFrame;

		public static ConfigEntry<string> DistanceRingColorOptions;

		public static ConfigEntry<bool> ControlSpawnerLevels;

		public static ConfigEntry<bool> ForceControlAllSpawns;

		public static ConfigEntry<bool> ControlBossSpawns;

		public static ConfigEntry<bool> ControlAbilitySpawnedCreatures;

		public static ConfigEntry<bool> EnableCreatureScalingPerLevel;

		public static ConfigEntry<bool> EnableScalingInDungeons;

		public static ConfigEntry<float> PerLevelScaleBonus;

		public static ConfigEntry<float> MinimumCreatureScale;

		public static ConfigEntry<float> PerLevelLootScale;

		public static ConfigEntry<float> PerLevelLootChanceScale;

		public static ConfigEntry<bool> ScaleAllLootByLevel;

		public static ConfigEntry<int> LootDropsPerTick;

		public static ConfigEntry<string> LootDropCalculationType;

		public static ConfigEntry<bool> LootEggsDropIncreaseStacks;

		public static ConfigEntry<bool> CreatureLootDropStacked;

		public static ConfigEntry<bool> TreeLootDropsStacked;

		public static ConfigEntry<bool> RockLootDropsStacked;

		public static ConfigEntry<bool> MiscLootDropsStacked;

		public static ConfigEntry<bool> EggLevelDeterminedByItemQuality;

		public static ConfigEntry<bool> OffspringCanBeStrongerThanParents;

		public static ConfigEntry<float> OffspringGainExtraLevelChance;

		public static ConfigEntry<bool> OffspringCanBeInfertile;

		public static ConfigEntry<float> OffspringChanceToBeInfertile;

		public static ConfigEntry<float> EnemyHealthMultiplier;

		public static ConfigEntry<float> BossEnemyHealthMultiplier;

		public static ConfigEntry<float> EnemyHealthPerWorldLevel;

		public static ConfigEntry<float> EnemyDamageLevelMultiplier;

		public static ConfigEntry<float> BossEnemyDamageMultiplier;

		public static ConfigEntry<bool> EnableScalingBirds;

		public static ConfigEntry<float> BirdSizeScalePerLevel;

		public static ConfigEntry<bool> EnableScalingFish;

		public static ConfigEntry<float> FishSizeScalePerLevel;

		public static ConfigEntry<bool> EnableTreeScaling;

		public static ConfigEntry<float> TreeSizeScalePerLevel;

		public static ConfigEntry<bool> UseDeterministicTreeScaling;

		public static ConfigEntry<bool> RandomizeTameChildrenLevels;

		public static ConfigEntry<bool> RandomizeTameChildrenModifiers;

		public static ConfigEntry<bool> SpawnMultiplicationAppliesToTames;

		public static ConfigEntry<bool> BossCreaturesNeverSpawnMultiply;

		public static ConfigEntry<bool> EnableColorization;

		public static ConfigEntry<bool> EnableRockLevels;

		public static ConfigEntry<bool> EnableRidableCreatureSizeFixes;

		public static ConfigEntry<bool> MultipliedNightSpawnsRemovedDuringDay;

		public static ConfigEntry<float> PerLevelTreeLootScale;

		public static ConfigEntry<float> PerLevelBirdLootScale;

		public static ConfigEntry<float> PerLevelMineRockLootScale;

		public static ConfigEntry<float> PerLevelDestructibleLootScale;

		public static ConfigEntry<int> FishMaxLevel;

		public static ConfigEntry<int> BirdMaxLevel;

		public static ConfigEntry<int> TreeMaxLevel;

		public static ConfigEntry<int> RockMaxLevel;

		public static ConfigEntry<int> DestructibleMaxLevel;

		public static ConfigEntry<int> MaxMajorModifiersPerCreature;

		public static ConfigEntry<int> MaxMinorModifiersPerCreature;

		public static ConfigEntry<bool> LimitCreatureModifiersToCreatureStarLevel;

		public static ConfigEntry<float> ChanceMajorModifier;

		public static ConfigEntry<float> ChanceMinorModifier;

		public static ConfigEntry<bool> EnableBossModifiers;

		public static ConfigEntry<float> ChanceOfBossModifier;

		public static ConfigEntry<int> MaxBossModifiersPerBoss;

		public static ConfigEntry<bool> SplittersInheritLevel;

		public static ConfigEntry<int> LimitCreatureModifierPrefixes;

		public static ConfigEntry<bool> MinorModifiersFirstInName;

		public static ConfigEntry<bool> EnableDistanceLevelScalingBonus;

		public static ConfigEntry<bool> EnableMultiplayerEnemyHealthScaling;

		public static ConfigEntry<bool> EnableMultiplayerEnemyDamageScaling;

		public static ConfigEntry<int> MultiplayerScalingRequiredPlayersNearby;

		public static ConfigEntry<float> MultiplayerEnemyDamageModifier;

		public static ConfigEntry<float> MultiplayerEnemyHealthModifier;

		public static ConfigEntry<float> MultiplayerEnemyMinDamageTaken;

		public static ConfigEntry<int> NumberOfCacheUpdatesPerFrame;

		public static ConfigEntry<bool> OutputColorizationGeneratorsData;

		public static ConfigEntry<int> FallbackDelayBeforeCreatureSetup;

		public static ConfigEntry<float> InitialDelayBeforeSetup;

		public static ConfigEntry<bool> EnableDebugOutputForDamage;

		public static ConfigEntry<bool> EnableDebugOutputLevelRolls;

		public static ConfigEntry<bool> EnableDebugLootDetails;

		public static ConfigEntry<string> ModifierIconDisplayStyle;

		public static ConfigEntry<float> EnemyHealthbarScalarX;

		public static ConfigEntry<float> EnemyHealthbarScalarY;

		public static ConfigEntry<bool> EnableEnemyHealthbarNumberDisplay;

		public static ConfigEntry<float> HealthDisplayFontSizeAdjustment;

		public static ConfigEntry<bool> StackMultipleBossHealthbars;

		public static ConfigEntry<float> BossHealthbarSpacing;

		public static ConfigEntry<int> BossHudTopBuffer;

		public static ConfigEntry<float> BossHealthbarWidthPercent;

		public static ConfigEntry<bool> EnableJewelCraftingBossHudCompat;

		public static ConfigEntry<bool> UseCustomHealthFont;

		public static ConfigEntry<bool> OnlyControlVanillaAreaSpawners;

		public static ConfigEntry<bool> OverrideCreatureModifiedHealth;

		public static ConfigEntry<bool> UseVanillaRaidConfiguration;

		public static ConfigEntry<float> RaidEventRate;

		public static ConfigEntry<int> MaxActiveRaids;

		public static ConfigEntry<int> MaxRaidAttemptsPerPlayer;

		public static ConfigEntry<int> ServerTimeBetweenRaidStartChecks;

		public static ConfigEntry<int> RaidWindDownSeconds;

		public static ConfigEntry<bool> RaidForceDeleteStragglers;

		public static ConfigEntry<bool> EnableDebugRaidDetails;

		public static ConfigEntry<bool> EnableCustomRaidsCompat;

		public static ConfigEntry<bool> EnableNemesisSystem;

		public static ConfigEntry<bool> EnableNemesisRemoteSpawning;

		public static ConfigEntry<bool> EnableDebugNemesisDetails;

		public static ConfigEntry<bool> EnableZoneScalingBonus;

		public static ConfigEntry<float> ZoneLevelBonusPerLevel;

		public static ConfigEntry<int> ZoneKillsPerLevelUp;

		public static ConfigEntry<float> ZoneDecayLevelsPerHour;

		public static ConfigEntry<bool> EnableZoneMapOverlay;

		public static ConfigEntry<bool> ZoneOverlayAboveFog;

		public static ConfigEntry<float> MinZoneSize;

		public static ConfigEntry<float> MaxZoneSize;

		public static ConfigEntry<float> KillReportFlushIntervalSeconds;

		public static ConfigEntry<string> ZoneOverlayColorOptions;

		public static ConfigEntry<bool> ShowMinimapLevelIndicator;

		public static ConfigEntry<float> ZoneOverlayColorTransparency;

		public static ConfigEntry<bool> ShowQuickConfigureButton;

		public static ConfigEntry<float> ConfigPollIntervalSeconds;

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

		public void SetupConfigRPCs()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0027: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0053: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_007f: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00ab: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00d7: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_0103: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_012f: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_015b: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			//IL_0187: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Expected O, but got Unknown
			//IL_01b3: Expected O, but got Unknown
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_01df: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			//IL_020b: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Expected O, but got Unknown
			//IL_0237: Expected O, but got Unknown
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Expected O, but got Unknown
			//IL_0263: Expected O, but got Unknown
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Expected O, but got Unknown
			//IL_028f: Expected O, but got Unknown
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Expected O, but got Unknown
			//IL_02bb: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Expected O, but got Unknown
			//IL_02e7: Expected O, but got Unknown
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Expected O, but got Unknown
			//IL_0313: Expected O, but got Unknown
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Expected O, but got Unknown
			//IL_033f: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Expected O, but got Unknown
			//IL_036b: Expected O, but got Unknown
			LevelSettingsRPC = NetworkManager.Instance.AddRPC("SLS_LevelsRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveLevelConfigs));
			ColorSettingsRPC = NetworkManager.Instance.AddRPC("SLS_ColorsRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveColorConfigs));
			CreatureLootSettingsRPC = NetworkManager.Instance.AddRPC("SLS_CreatureLootRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveCreatureLootConfigs));
			ModifiersRPC = NetworkManager.Instance.AddRPC("SLS_ModifiersRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveModifiersConfigs));
			RaidsRPC = NetworkManager.Instance.AddRPC("SLS_RaidsRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveRaidConfigs));
			NemesisRPC = NetworkManager.Instance.AddRPC("SLS_NemesisRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveNemesisConfigs));
			ClientSendPlayerPrivateKeysRPC = NetworkManager.Instance.AddRPC("SLS_SendPlayerKeysRPC", new CoroutineHandler(OnServerReceivePlayerPrivateKeys), new CoroutineHandler(OnClientReceiveRequestForPrivateKeys));
			ClientStartRaidRPC = NetworkManager.Instance.AddRPC("SLS_ClientStartRaidRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveRaidStart));
			RaidCommittedRPC = NetworkManager.Instance.AddRPC("SLS_RaidCommittedRPC", new CoroutineHandler(OnServerReceiveRaidCommitted), new CoroutineHandler(NOOPReceive));
			ClientForcePlayMusicRPC = NetworkManager.Instance.AddRPC("SLS_ClientForcePlayMusicRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveForcePlayMusic));
			ClientClearNearbyEventsRPC = NetworkManager.Instance.AddRPC("SLS_ClientForceRemoveNearbyEventsRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveForceRemoveNearbyEvents));
			SendNewNemesisBossRPC = NetworkManager.Instance.AddRPC("SLS_SendNewNemesisBossRPC", new CoroutineHandler(OnServerReceivedNemesisBossAdd), new CoroutineHandler(OnClientReceiveMiniBossAdd));
			RemoveNemesisBossRPC = NetworkManager.Instance.AddRPC("SLS_RemoveNemesisBossRPC", new CoroutineHandler(OnServerReceiveNemesisBossRemove), new CoroutineHandler(OnClientReceiveMiniBossRemove));
			AddNemesisBossPinRPC = NetworkManager.Instance.AddRPC("SLS_AddNemesisBossPinRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveNemesisBossPinAdd));
			RemoveNemesisBossPinRPC = NetworkManager.Instance.AddRPC("SLS_RemoveNemesisBossPinRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceiveNemesisBossPinRemove));
			ReportNemesisBossDeathRPC = NetworkManager.Instance.AddRPC("SLS_ReportNemesisBossDeathRPC", new CoroutineHandler(OnServerReceiveNemesisBossDeath), new CoroutineHandler(NOOPReceive));
			ClientRequestNemesisRemoteSpawnRPC = NetworkManager.Instance.AddRPC("SLS_ClientRequestNemesisRemoteSpawnRPC", new CoroutineHandler(OnServerReceiveNemesisRemoteSpawnRequest), new CoroutineHandler(NOOPReceive));
			ClientPlaceNemesisSpawnerRPC = NetworkManager.Instance.AddRPC("SLS_ClientPlaceNemesisSpawnerRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(OnClientReceivePlaceNemesisSpawner));
			ZoneKillReportRPC = NetworkManager.Instance.AddRPC("SLS_ZoneKillReportRPC", new CoroutineHandler(OnServerReceiveZoneKills), new CoroutineHandler(NOOPReceive));
			ZoneLevelSyncRPC = NetworkManager.Instance.AddRPC("SLS_ZoneLevelSyncRPC", new CoroutineHandler(OnServerReceiveConfigs), new CoroutineHandler(ZoneScaleSystemData.OnClientReceiveZoneLevels));
			SynchronizationManager.Instance.AddInitialSynchronization(ClientSendPlayerPrivateKeysRPC, (Func<ZPackage>)SendRequestForPrivateKeys);
			SynchronizationManager.Instance.AddInitialSynchronization(LevelSettingsRPC, (Func<ZPackage>)SendLevelsConfigs);
			SynchronizationManager.Instance.AddInitialSynchronization(ColorSettingsRPC, (Func<ZPackage>)SendColorsConfigs);
			SynchronizationManager.Instance.AddInitialSynchronization(CreatureLootSettingsRPC, (Func<ZPackage>)SendCreatureLootConfigs);
			SynchronizationManager.Instance.AddInitialSynchronization(ModifiersRPC, (Func<ZPackage>)SendModifierConfigs);
			SynchronizationManager.Instance.AddInitialSynchronization(RaidsRPC, (Func<ZPackage>)SendRaidConfigs);
			SynchronizationManager.Instance.AddInitialSynchronization(NemesisRPC, (Func<ZPackage>)SendNemesisConfigs);
			SynchronizationManager.Instance.AddInitialSynchronization(AddNemesisBossPinRPC, (Func<ZPackage>)SendNemesisBossPins);
			SynchronizationManager.Instance.AddInitialSynchronization(ZoneLevelSyncRPC, (Func<ZPackage>)ZoneScaleSystemData.SerializeLeveledZonesForSync);
		}

		private void CreateConfigValues(ConfigFile Config)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			//IL_123b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1245: Expected O, but got Unknown
			//IL_1273: Unknown result type (might be due to invalid IL or missing references)
			//IL_127d: Expected O, but got Unknown
			EnableDebugMode = Config.Bind<bool>("Client config", "EnableDebugMode", false, new ConfigDescription("Enables Debug logging.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} }));
			EnableDebugMode.SettingChanged += Logger.EnableDebugLogging;
			Logger.CheckEnableDebugLogging();
			EnableDebugOutputForDamage = Config.Bind<bool>("Client config", "EnableDebugOutputForDamage", false, new ConfigDescription("Enables Detailed logging for damage calculations, warning, lots of logging.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} }));
			EnableDebugOutputLevelRolls = Config.Bind<bool>("Client config", "EnableDebugOutputLevelRolls", false, new ConfigDescription("Enables Detailed logging for creature levelup rolls.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} }));
			EnableDebugLootDetails = Config.Bind<bool>("Client config", "EnableDebugLootDetails", false, new ConfigDescription("Enables Detailed logging for loot generation.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} }));
			EnableDebugNemesisDetails = Config.Bind<bool>("Client config", "EnableDebugNemesisDetails", false, new ConfigDescription("Enables Detailed logging for the Nemesis system.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} }));
			EnableDebugRaidDetails = Config.Bind<bool>("Client config", "EnableDebugRaidDetails", false, new ConfigDescription("Enables Detailed logging for the Raid system.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} }));
			ShowMinimapLevelIndicator = Config.Bind<bool>("Client config", "ShowMinimapLevelIndicator", true, new ConfigDescription("Show a small ring/zone level readout next to the minimap. Each section is hidden when its scaling system is disabled.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes() }));
			ShowMinimapLevelIndicator.SettingChanged += MinimapLevelIndicator.OnShowIndicatorChanged;
			ShowQuickConfigureButton = Config.Bind<bool>("Client config", "ShowQuickConfigureButton", true, new ConfigDescription("Show the StarLevelSystem quick configuration button on the main menu and (for hosts/admins) the pause menu.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes() }));
			ShowQuickConfigureButton.SettingChanged += QuickConfigureTool.OnShowButtonChanged;
			MaxLevel = BindServerConfig("LevelSystem", "MaxLevel", 20, "The Maximum number of stars that a creature can have.", advanced: false, 1, 200);
			MaxLevel.SettingChanged += UpdateLevelsOnChange.ModifyLoadedCreatureLevels;
			MaxBossLevel = BindServerConfig("LevelSystem", "MaxBossLevel", 10, "The Maximum number of stars that a boss creature can have.", advanced: false, 1, 200);
			OverLevelCreaturesGetRerolledOnLoad = BindServerConfig("LevelSystem", "OverlevedCreaturesGetRerolledOnLoad", value: true, "Rerolls creature levels which are above maximum defined level, when those creatures are loaded. This will automatically clean up over leveled creatures if you reduce the max level.");
			EnableCreatureScalingPerLevel = BindServerConfig("LevelSystem", "EnableCreatureScalingPerLevel", value: true, "Enables started creatures to get larger for each star");
			EnableDistanceLevelScalingBonus = BindServerConfig("LevelSystem", "EnableDistanceLevelScalingBonus", value: true, "Creatures further away from the center of the world have a higher chance to levelup, this is a bonus applied to existing creature/biome configuration.");
			EnableMapRingsForDistanceBonus = BindServerConfig("LevelSystem", "EnableMapRingsForDistanceBonus", value: true, "Enables map rings to show distance levels, this is a visual aid to help you see how far away from the center of the world you are.");
			EnableMapRingsForDistanceBonus.SettingChanged += DistanceScaleSystem.UpdateMapRingEnableSettingOnChange;
			MapRingsAboveFog = BindServerConfig("LevelSystem", "MapRingsAboveFog", value: false, "When enabled, distance map rings draw above the map fog so they are visible even in unexplored areas. When disabled, rings sit below the fog and only appear once an area has been explored.");
			MapRingsAboveFog.SettingChanged += DistanceScaleSystem.UpdateMapRingFogSettingOnChange;
			DistanceBonusIsFromStarterTemple = BindServerConfig("LevelSystem", "DistanceBonusIsFromStarterTemple", value: false, "When enabled the distance bonus is calculated from the starter temple instead of world center, typically this makes little difference. But can help ensure your starting area is more correctly calculated.");
			DistanceBonusIsFromStarterTemple.SettingChanged += DistanceScaleSystem.OnRingCenterChanged;
			DistanceRingColorOptions = BindServerConfig("LevelSystem", "DistanceRingColorOptions", "White,Blue,Teal,Green,Yellow,Purple,Orange,Pink,Purple,Red,Grey", "The colors that distance rings will use, if there are more rings than colors, the color pattern will be repeated. (Optional, use an HTML hex color starting with # to have a custom color.) Available options: Red, Orange, Yellow, Green, Teal, Blue, Purple, Pink, Gray, Brown, Black");
			DistanceRingColorOptions.SettingChanged += DistanceScaleSystem.UpdateMapColorSettingsOnChange;
			MiniMapRingGeneratorUpdatesPerFrame = BindServerConfig("LevelSystem", "MiniMapRingGeneratorUpdatesPerFrame", 1000, "The number of ring points to calculate per frame when generating the minimap rings. Higher values make this go faster, but can get it killed or cause instability.", advanced: true);
			PerLevelScaleBonus = BindServerConfig("LevelSystem", "PerLevelScaleBonus", 0.1f, "The size a creature gains each star level. Negative values shrink creatures each star, down to MinimumCreatureScale.", advanced: true, -0.5f, 2f);
			PerLevelScaleBonus.SettingChanged += SizeModifications.StarLevelScaleChanged;
			MinimumCreatureScale = BindServerConfig("LevelSystem", "MinimumCreatureScale", 0.1f, "The smallest scale multiplier a creature can shrink to. Stops negative size-per-level values from producing zero-sized or inside-out creatures.", advanced: true, 0.01f, 1f);
			MinimumCreatureScale.SettingChanged += SizeModifications.StarLevelScaleChanged;
			EnableScalingInDungeons = BindServerConfig("LevelSystem", "EnableScalingInDungeons", value: false, "Enables scaling in dungeons, this can cause creatures to become stuck.");
			EnableColorization = BindServerConfig("LevelSystem", "EnableColorization", value: true, "Enables this mods colorization of creatures based on their star level.");
			EnemyHealthMultiplier = BindServerConfig("LevelSystem", "EnemyHealthMultiplier", 1f, "The amount of health that each level gives a creature, vanilla is 1x.", advanced: false, 0f, 5f);
			EnemyHealthPerWorldLevel = BindServerConfig("LevelSystem", "EnemyHealthPerWorldLevel", 0.2f, "The percent amount of health that each world level gives a creature, vanilla is 2x (eg 200% more health each world level).", advanced: false, 0f, 2f);
			EnemyDamageLevelMultiplier = BindServerConfig("LevelSystem", "EnemyDamageLevelMultiplier", 0.1f, "The amount of damage that each level gives a creatures, vanilla is 0.5x (eg 50% more damage each level).", advanced: false, 0f, 2f);
			BossEnemyHealthMultiplier = BindServerConfig("LevelSystem", "BossEnemyHealthMultiplier", 0.3f, "The amount of health that each level gives a boss. 1 is 100% more health per level.", advanced: false, 0f, 5f);
			BossEnemyDamageMultiplier = BindServerConfig("LevelSystem", "BossEnemyDamageMultiplier", 0.02f, "The amount of damage that each level gives a boss. 1 is 100% more damage per level.", advanced: false, 0f, 5f);
			RandomizeTameChildrenLevels = BindServerConfig("LevelSystem", "RandomizeTameLevels", value: false, "Randomly rolls bred creature levels, instead of inheriting from parent.");
			RandomizeTameChildrenModifiers = BindServerConfig("LevelSystem", "RandomizeTameChildrenModifiers", value: true, "Randomly rolls bred creatures modifiers instead of inheriting from a parent");
			SpawnMultiplicationAppliesToTames = BindServerConfig("LevelSystem", "SpawnMultiplicationAppliesToTames", value: false, "Spawn multipliers set on creature or biome will apply to produced tames when enabled.");
			BossCreaturesNeverSpawnMultiply = BindServerConfig("LevelSystem", "BossCreaturesNeverSpawnMultiply", value: true, "Boss creatures never have spawn multipliers applied to them.");
			EnableRidableCreatureSizeFixes = BindServerConfig("LevelSystem", "EnableRidableCreatureSizeFixes", value: true, "Enables collider fixes for ridable creatures (lox and Askavin).");
			MultipliedNightSpawnsRemovedDuringDay = BindServerConfig("LevelSystem", "MultipliedNightSpawnsRemovedDuringDay", value: true, "When true, night spawns will be flagged to despawn during the day, which will result in them running away and despawning. This can be disabled if desired.");
			EnableScalingBirds = BindServerConfig("ObjectLevels", "EnableScalingBirds", value: true, "Enables birds to scale with the level system. This will cause them to become larger and give more drops.");
			EnableScalingBirds.SettingChanged += UpdateLevelsOnChange.UpdateBirdSizeOnConfigChange;
			BirdSizeScalePerLevel = BindServerConfig("ObjectLevels", "BirdSizeScalePerLevel", 0.1f, "The amount of size that birds gain per level. 0.1 = 10% larger per level.", advanced: true, 0f, 2f);
			BirdSizeScalePerLevel.SettingChanged += UpdateLevelsOnChange.UpdateBirdSizeOnConfigChange;
			EnableScalingFish = BindServerConfig("ObjectLevels", "EnableScalingFish", value: true, "Enables star scaling for fish. This does potentially allow huge fish.");
			EnableScalingFish.SettingChanged += UpdateLevelsOnChange.UpdateFishSizeOnConfigChange;
			EnableRockLevels = BindServerConfig("ObjectLevels", "EnableRockLevels", value: false, "Enables level scaling for rocks.");
			FishMaxLevel = BindServerConfig("ObjectLevels", "FishMaxLevel", 20, "Sets the max level that fish can scale up to.", advanced: true, 1);
			BirdMaxLevel = BindServerConfig("ObjectLevels", "BirdMaxLevel", 10, "Sets the max level that birds can scale up to.", advanced: true, 1);
			TreeMaxLevel = BindServerConfig("ObjectLevels", "TreeMaxLevel", 10, "Sets the max level that trees can scale up to.", advanced: true, 1);
			RockMaxLevel = BindServerConfig("ObjectLevels", "RockMaxLevel", 10, "Sets the max level that rocks can scale up to.", advanced: true, 1);
			DestructibleMaxLevel = BindServerConfig("ObjectLevels", "DestructibleMaxLevel", 1, "Sets the max level that generic destructibles can be leveled to", advanced: true, 1);
			FishSizeScalePerLevel = BindServerConfig("ObjectLevels", "FishSizeScalePerLevel", 0.1f, "The amount of size that fish gain per level 0.1 = 10% larger per level.");
			FishSizeScalePerLevel.SettingChanged += UpdateLevelsOnChange.UpdateFishSizeOnConfigChange;
			EnableTreeScaling = BindServerConfig("ObjectLevels", "EnableTreeScaling", value: true, "Enables level scaling of trees. Make the trees bigger than reasonable? sure why not.");
			EnableTreeScaling.SettingChanged += UpdateLevelsOnChange.UpdateTreeSizeOnConfigChange;
			UseDeterministicTreeScaling = BindServerConfig("ObjectLevels", "UseDeterministicTreeScaling", value: true, "Scales the level of trees based on biome and distance from the center/spawn. This does not randomize tree levels, but reduces network usage.");
			TreeSizeScalePerLevel = BindServerConfig("ObjectLevels", "TreeSizeScalePerLevel", 0.1f, "The amount of size that trees gain per level 0.1 = 10% larger per level.");
			TreeSizeScalePerLevel.SettingChanged += UpdateLevelsOnChange.UpdateTreeSizeOnConfigChange;
			PerLevelTreeLootScale = BindServerConfig("ObjectLevels", "PerLevelTreeLootScale", 0.2f, "The amount of additional wood that each level grants for a tree.", advanced: true);
			PerLevelBirdLootScale = BindServerConfig("ObjectLevels", "PerLevelBirdLootScale", 0.3f, "Per level additional loot that birds gain.", advanced: true);
			PerLevelMineRockLootScale = BindServerConfig("ObjectLevels", "PerLevelMineRockLootScale", 0.2f, "The amount of additional stones and ores that each level grants for a rock", advanced: true);
			PerLevelDestructibleLootScale = BindServerConfig("ObjectLevels", "PerLevelDestructibleLootScale", 0.2f, "The amount of additional loot that destructible items grant for each level", advanced: true);
			MultiplayerEnemyDamageModifier = BindServerConfig("Multiplayer", "MultiplayerEnemyDamageModifier", 0.05f, "The additional amount of damage enemies will do to players, when there is a group of players together, per player. .2 = 20%. Vanilla gives creatures 4% more damage per player nearby.", advanced: true, 0f, 2f);
			MultiplayerEnemyHealthModifier = BindServerConfig("Multiplayer", "MultiplayerEnemyHealthModifier", 0.2f, "Enemies take reduced damage when there is a group of players, vanilla gives creatures 30% damage resistance per player nearby.", advanced: true, 0f, 0.99f);
			MultiplayerEnemyMinDamageTaken = BindServerConfig("Multiplayer", "MultiplayerEnemyMinDamageTaken", 0.2f, "Minimum amount of damage that enemies can take from multiplayer scaling. 0.2 = 20%", advanced: true);
			MultiplayerScalingRequiredPlayersNearby = BindServerConfig("Multiplayer", "MultiplayerScalingRequiredPlayersNearby", 3, "The number of players in a local area required to cause monsters to gain bonus health and/or damage.", advanced: true, 1, 20);
			EnableMultiplayerEnemyHealthScaling = BindServerConfig("Multiplayer", "EnableMultiplayerEnemyHealthScaling", value: true, "Creatures gain more health when players are grouped up.");
			EnableMultiplayerEnemyDamageScaling = BindServerConfig("Multiplayer", "EnableMultiplayerEnemyDamageScaling", value: false, "Creatures gain more damage when players are grouped up.");
			ControlSpawnerLevels = BindServerConfig("LevelSystem", "ControlSpawnerLevels", value: true, "Overrides spawner levels to be controlled by SLS (this impacts all naturally spawning creatures)");
			ControlAbilitySpawnedCreatures = BindServerConfig("LevelSystem", "ControlAbilitySpawnedCreatures", value: true, "Forces creatures spawned from abilities to be controlled by SLS. This primarily impacts things such as the roots from Elder.");
			ControlBossSpawns = BindServerConfig("LevelSystem", "ControlBossSpawns", value: true, "Forces boss creatures to be controlled by SLS. Bosses will not get star levels if this is disabled.");
			ForceControlAllSpawns = BindServerConfig("LevelSystem", "ForceControlAllSpawns", value: false, "Forces all creatures to be controlled by SLS, this includes creatures spawned from player abilities and items. This will override creature levels, other mods must use the API to ensure their spawned creature levels are set.");
			OffspringCanBeStrongerThanParents = BindServerConfig("LevelSystem", "OffspringCanBeStrongerThanParents", value: false, "When enabled, creatures that are bred can have higher levels than their parents. Otherwise, they will be capped at the highest parent level.");
			OffspringGainExtraLevelChance = BindServerConfig("LevelSystem", "OffspringGainExtraLevelChance", 0.05f, "When enabled, creatures that are bred have a chance to gain an extra level above their parents. Chance is based on this value, 0.1 = 10% chance.", advanced: false, 0f, 1f);
			OffspringCanBeInfertile = BindServerConfig("LevelSystem", "OffspringCanBeInfertile", value: false, "When enabled, creatures produced from breeding have a chance to be infertile.");
			OffspringChanceToBeInfertile = BindServerConfig("LevelSystem", "OffspringChanceToBeInfertile", 0.5f, "When enabled, the chance that a creature produced from breeding will be infertile.", advanced: true, 0f, 1f);
			PerLevelLootScale = BindServerConfig("LootSystem", "PerLevelLootScale", 1f, "The amount of additional loot that a creature provides per each star level", advanced: false, 0f, 4f);
			PerLevelLootChanceScale = BindServerConfig("LootSystem", "PerLevelLootChanceScale", 0.05f, "Under the PerLevel loot style only: additional chance per level that a sub-100% loot drop will occur, added on top of any per-drop ChanceScaleFactor. E.g. 0.05 = +5% drop chance per level. Has no effect on drops with a base Chance of 1.", advanced: false, 0f, 1f);
			LootDropCalculationType = BindServerConfig("LootSystem", "LootDropCalculationType", "PerLevel", "How loot amounts scale with level. PerLevel: amount scales linearly with level. Exponential: amount scales exponentially with level. ChancePerLevel: amount stays at its base, but each drop is an all-or-nothing lottery whose chance to drop grows with level (base amount or nothing).", LootStyles.AllowedLootFactors);
			LootStyles.ParseLootFactor();
			LootDropCalculationType.SettingChanged += LootStyles.LootFactorChanged;
			LootDropsPerTick = BindServerConfig("LootSystem", "LootDropsPerTick", 20, "The number of loot drops that are generated per tick, reducing this will reduce lag when massive amounts of loot is generated at once.", advanced: true, 1, 100);
			ScaleAllLootByLevel = BindServerConfig("LootSystem", "ScaleAllLootByLevel", value: false, "Enables scaling of all loot which does not normally scale per level. Typically this is just trophies.");
			LootEggsDropIncreaseStacks = BindServerConfig("LootSystem", "LootEggsDropIncreaseStacks", value: true, "This causes higher level chickens (and other egg producers) to drop MORE eggs instead of higher leveled ones.");
			EggLevelDeterminedByItemQuality = BindServerConfig("LootSystem", "EggLevelDeterminedByItemQuality", value: false, "When enabled, the level of egg grown creatures is determined by the eggs quality level. Otherwise the grown creature uses its default level configuration.");
			CreatureLootDropStacked = BindServerConfig("LootSystem", "CreatureLootDropStacked", value: true, "When enabled, character drops will be automatically stacked before dropping (significantly more performant).");
			TreeLootDropsStacked = BindServerConfig("LootSystem", "TreeLootDropsStacked", value: true, "When enabled, tree drops will be automatically stacked before dropping (significantly more performant).");
			RockLootDropsStacked = BindServerConfig("LootSystem", "RockLootDropsStacked", value: true, "When enabled, rock drops will be automatically stacked before dropping (significantly more performant).");
			MiscLootDropsStacked = BindServerConfig("LootSystem", "MiscLootDropsStacked", value: true, "When enabled, misc (such as small destructible skeletons etc) drops will be automatically stacked before dropping (significantly more performant).");
			UseVanillaRaidConfiguration = BindServerConfig("Raids", "UseVanillaRaidConfiguration", value: false, "Reverts to use vanilla raid configuration when enabled.");
			RaidEventRate = BindServerConfig("Raids", "RaidEventRate", 1f, "The rate at which raid events occur (Vanilla is 1.0), higher values result in less frequent raids, lower values results in more frequent raids. This modifies the raid timing settings which are set per-raid.", advanced: false, 0.001f, 10f);
			MaxRaidAttemptsPerPlayer = BindServerConfig("Raids", "MaxRaidAttemptsPerPlayer", 5, "The Maximum number of times to try to activate a raid for a given player. The available raids will be shuffled each time before rolling their activation chance. With 10 raids defined the randomly selected first X will get a chance to spawn.", advanced: true, 0, 50);
			ServerTimeBetweenRaidStartChecks = BindServerConfig("Raids", "ServerTimeBetweenRaidStartChecks", 25, "Number of minutes between when the server will check to start raids (raids can still be on cooldown and will not be started).", advanced: true, 1, 120);
			MaxActiveRaids = BindServerConfig("Raids", "MaxActiveRaids", 10, "The maximum number of concurrent raids, automatically limited to 1 per player.");
			RaidWindDownSeconds = BindServerConfig("Raids", "RaidWindDownSeconds", 60, "Seconds after a raid ends during which its creatures move away and despawn naturally. 0 = no linger.", advanced: true, 0, 600);
			RaidForceDeleteStragglers = BindServerConfig("Raids", "RaidForceDeleteStragglers", value: true, "When enabled, any raid creatures still present at the end of RaidWindDownSeconds are force-deleted. When disabled, leftover creatures are left to wander off and despawn on their own.", null, advanced: true);
			EnableCustomRaidsCompat = BindServerConfig("Raids", "EnableCustomRaidsCompat", value: true, "When CustomRaids is installed and SLS raids are enabled, allow CustomRaids raids to fire alongside SLS raids. Has no effect if CustomRaids is not installed.", null, advanced: true);
			EnableNemesisSystem = BindServerConfig("Nemesis", "EnableNemesisSystem", value: true, "Enables the per-player Nemesis system that biases newly-spawning creature star levels based on a tracked player score.");
			EnableNemesisRemoteSpawning = BindServerConfig("Nemesis", "EnableNemesisRemoteSpawning", value: false, "Enables ambient, server-driven remote spawning of Nemesis minibosses across the world (a second, finer gate lives in NemesisSettings.yaml under RemoteSpawning.Enabled).");
			EnableZoneScalingBonus = BindServerConfig("ZoneScaling", "EnableZoneScalingBonus", value: true, "Divides the world into island-based zones. Zones gain levels from creature kills and apply bonus level-up chances to creatures that spawn inside them.");
			ZoneLevelBonusPerLevel = BindServerConfig("ZoneScaling", "ZoneLevelBonusPerLevel", 2f, "Bonus added to each level-up chance tier for each zone level above 1. E.g. 2.0 at zone level 3 adds +4 to every tier.", advanced: false, 0.1f, 50f);
			ZoneKillsPerLevelUp = BindServerConfig("ZoneScaling", "ZoneKillsPerLevelUp", 100, "Number of creature deaths in a zone required to raise that zone's level by 1.", advanced: false, 1, 10000);
			ZoneDecayLevelsPerHour = BindServerConfig("ZoneScaling", "ZoneDecayLevelsPerHour", 0.25f, "How many zone levels decay per real-time hour. 0 disables decay entirely; lower values decay slower, higher values faster. Default 0.25 = one level lost every four hours.", advanced: false, 0f, 50f);
			EnableZoneMapOverlay = BindServerConfig("ZoneScaling", "EnableZoneMapOverlay", value: true, "Draws zone boundaries on the minimap, colored by zone level.");
			ZoneOverlayAboveFog = BindServerConfig("ZoneScaling", "ZoneOverlayAboveFog", value: false, "When enabled, zone boundaries draw above the map fog so they are visible even in unexplored areas. When disabled, boundaries sit below the fog and only appear once an area has been explored.");
			ZoneOverlayAboveFog.SettingChanged += ZoneScaleSystem.UpdateZoneOverlayFogOnChange;
			MinZoneSize = BindServerConfig("ZoneScaling", "MinZoneSize", 1000f, "Minimum landmass size (meters, on both axes) for an island to be split into zones. Islands smaller than this get no zones. Changes apply when zones are rebuilt (SLS-rebuild-zones).", advanced: false, 500f, 10000f);
			MaxZoneSize = BindServerConfig("ZoneScaling", "MaxZoneSize", 3000f, "Side length (meters) of each square zone cell. Land is tiled onto a global grid of this size so zones never overlap. Changes apply when zones are rebuilt (SLS-rebuild-zones).", advanced: false, 1000f, 10000f);
			KillReportFlushIntervalSeconds = BindServerConfig("ZoneScaling", "KillReportFlushIntervalSeconds", 10f, "The number of seconds between update checks for zone kill counters.", advanced: true);
			ZoneOverlayColorOptions = BindServerConfig("ZoneScaling", "ZoneOverlayColorOptions", "Grey,White,LightYellow,Yellow,LightOrange,Orange,DarkOrange,LightRed,Red,DarkRed,LightPurple,Purple,DarkPurple", "The colors used for zone boundaries on the minimap, walked by zone level (higher levels step further along the list, wrapping if there are more levels than colors). (Optional, use an HTML hex color starting with # to have a custom color.) Available options: LightYellow, Yellow, LightOrange, Orange, DarkOrange, LightRed, Red, DarkRed, LightPurple, Purple, DarkPurple, Green, Teal, Blue, Pink, Gray, Brown, Black, White");
			ZoneOverlayColorOptions.SettingChanged += ZoneScaleSystem.UpdateZoneOverlayColorsOnChange;
			ZoneOverlayColorTransparency = BindServerConfig("ZoneScaling", "ZoneOverlayColorTransparency", 0.5f, "Transparency value of the color used for zone boundaries.", advanced: true, 0f, 1f);
			ZoneOverlayColorTransparency.SettingChanged += ZoneScaleSystem.UpdateZoneOverlayColorsOnChange;
			MaxMajorModifiersPerCreature = BindServerConfig("Modifiers", "MaxMajorModifiersPerCreature", 1, "The default number of major modifiers that a creature can have.");
			MaxMinorModifiersPerCreature = BindServerConfig("Modifiers", "MaxMinorModifiersPerCreature", 1, "The default number of minor modifiers that a creature can have.");
			LimitCreatureModifiersToCreatureStarLevel = BindServerConfig("Modifiers", "LimitCreatureModifiersToCreatureStarLevel", value: true, "Limits the number of modifiers that a creature can have based on its level.");
			ChanceMajorModifier = BindServerConfig("Modifiers", "ChanceMajorModifier", 0.15f, "The chance that a creature will have a major modifier (creatures can have BOTH major and minor modifiers).", advanced: false, 0f, 1f);
			ChanceMajorModifier.SettingChanged += CreatureModifiersData.ClearProbabilityCaches;
			ChanceMinorModifier = BindServerConfig("Modifiers", "ChanceMinorModifier", 0.25f, "The chance that a creature will have a minor modifier (creatures can have BOTH major and minor modifiers).", advanced: false, 0f, 1f);
			ChanceMinorModifier.SettingChanged += CreatureModifiersData.ClearProbabilityCaches;
			EnableBossModifiers = BindServerConfig("Modifiers", "EnableBossModifiers", value: true, "Bosses can spawn with modifiers.");
			ChanceOfBossModifier = BindServerConfig("Modifiers", "ChanceOfBossModifier", 0.75f, "The chance that a boss will have a modifier.", advanced: false, 0f, 1f);
			ChanceOfBossModifier.SettingChanged += CreatureModifiersData.ClearProbabilityCaches;
			MaxBossModifiersPerBoss = BindServerConfig("Modifiers", "MaxBossModifiersPerBoss", 2, "The maximum number of modifiers that a boss can have.");
			SplittersInheritLevel = BindServerConfig("Modifiers", "SplittersInheritLevel", value: true, "Creatures spawned from the Splitter modifier inherit the level of the parent creature.");
			LimitCreatureModifierPrefixes = BindServerConfig("Modifiers", "LimitCreatureModifierPrefixes", 3, "Maximum number of prefix names to use when building a creatures name.");
			MinorModifiersFirstInName = BindServerConfig("Modifiers", "MinorModifiersFirstInName", value: false, "Enables or disables ordering of modifiers for naming. If enabled, minor modifiers will be sorted first eg: Fast Poisonous");
			ModifierIconDisplayStyle = BindServerConfig("Modifiers", "ModifierIconDisplayStyle", DataObjects.ModifierDisplayStyle.Stars.ToString(), "Style to display modifiers as on the creature HUD. Icons = detailed modifier icons, Stars = star-shaped modifier icons, None = plain default stars.", new AcceptableValueList<string>(new string[3]
			{
				DataObjects.ModifierDisplayStyle.Icons.ToString(),
				DataObjects.ModifierDisplayStyle.Stars.ToString(),
				DataObjects.ModifierDisplayStyle.None.ToString()
			}));
			CreatureModifiersData.ParseModifierDisplayStyle();
			ModifierIconDisplayStyle.SettingChanged += CreatureModifiersData.ModifierDisplayStyleChanged;
			EnemyHealthbarScalarX = BindServerConfig("UI", "EnemyHealthbarScalarX", 1f, "The scale of the health bar for typical enemies. This does not impact bosses or players.", advanced: false, 0f, 4f);
			EnemyHealthbarScalarY = BindServerConfig("UI", "EnemyHealthbarScalarY", 1.75f, "The scale of the health bar for typical enemies. This does not impact bosses or players.", advanced: false, 0f, 4f);
			UseCustomHealthFont = Config.Bind<bool>("UI", "UseCustomHealthFont", false, "[Client side Config] Enable to use a custom version of the Norse font.");
			HealthDisplayFontSizeAdjustment = BindServerConfig("UI", "HealthDisplayFontSizeAdjustment", 0.8f, "Percentage modification for the font size on creature health.");
			EnableEnemyHealthbarNumberDisplay = BindServerConfig("UI", "EnableEnemyHealthbarNumberDisplay", value: false, "Enables a numerical display for enemy creatures health");
			StackMultipleBossHealthbars = BindServerConfig("UI", "StackMultipleBossHealthbars", value: true, "When more than one boss healthbar is shown, stack them vertically (one full bar per row). When disabled, the boss bars are squished horizontally so they sit side-by-side.");
			BossHealthbarSpacing = BindServerConfig("UI", "BossHealthbarSpacing", 30f, "Gap, in pixels, between boss healthbars (vertical gap when stacked, horizontal gap when squished).", advanced: true, 0f, 120f);
			BossHudTopBuffer = Config.Bind<int>("UI", "BossHudTopBuffer", 120, new ConfigDescription("[Client side Config] Space, in 1080p-equivalent pixels, between the top of the screen and the boss health HUD.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 600), Array.Empty<object>()));
			BossHealthbarWidthPercent = Config.Bind<float>("UI", "BossHealthbarWidthPercent", 0.4f, new ConfigDescription("[Client side Config] Boss health bar width as a fraction of the screen width.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), Array.Empty<object>()));
			StackMultipleBossHealthbars.SettingChanged += UIHudControl.OnBossHudConfigChanged;
			BossHealthbarSpacing.SettingChanged += UIHudControl.OnBossHudConfigChanged;
			BossHudTopBuffer.SettingChanged += UIHudControl.OnBossHudConfigChanged;
			BossHealthbarWidthPercent.SettingChanged += UIHudControl.OnBossHudConfigChanged;
			EnableJewelCraftingBossHudCompat = BindServerConfig("UI", "EnableJewelcraftingBossHudCompat", value: true, "When Jewelcrafting is installed, suppress its multi-boss HUD layout (which rescales the boss health bar every frame) so SLS controls the boss healthbars. Has no effect if Jewelcrafting is not installed.", null, advanced: true);
			NumberOfCacheUpdatesPerFrame = BindServerConfig("Misc", "NumberOfCacheUpdatesPerFrame", 10, "Number of cache updates to process when performing live updates", advanced: true, 1);
			OutputColorizationGeneratorsData = BindServerConfig("Misc", "OutputColorizationGeneratorsData", value: false, "Writes out color generators to a debug file. This can be useful if you want to hand pick color settings from generated values.");
			InitialDelayBeforeSetup = BindServerConfig("Misc", "InitialDelayBeforeSetup", 0.5f, "The delay waited before a creature is setup, this is the delay that the person controlling the creature will wait before setup. Higher values will delay setup.");
			FallbackDelayBeforeCreatureSetup = BindServerConfig("Misc", "FallbackDelayBeforeCreatureSetup", 5, "The number of seconds non-owned creatures we will waited on before loading their modified attributes. This is a fallback setup.");
			ConfigPollIntervalSeconds = BindServerConfig("Misc", "ConfigPollIntervalSeconds", 30f, "The number of seconds between checks for changes in the yaml config files.", advanced: true, 1f, 300f);
			OnlyControlVanillaAreaSpawners = BindServerConfig("ModCompat", "OnlyControlVanillaAreaSpawners", value: true, "When enabled, will only control the spawned level from an AreaSpawner if it is a vanilla one.");
			OverrideCreatureModifiedHealth = BindServerConfig("ModCompat", "OverrideCreatureModifiedHealth", value: false, "When enabled, will always set creatures health based on the SLS settings for the creature. This overrides other mods changes to creatures.");
		}

		internal static void HasServerUpdates()
		{
			ServerConfigsSynced = true;
		}

		internal void LoadYamlConfigs()
		{
			string[] files = Directory.GetFiles(GetSecondaryConfigDirectoryPath());
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			bool flag5 = false;
			bool flag6 = false;
			string[] array = files;
			foreach (string text in array)
			{
				if (text.Contains("LevelSettings.yaml"))
				{
					Logger.LogDebug("Found level configuration: " + text);
					levelsFilePath = text;
					flag = true;
				}
				if (text.Contains("ColorSettings.yaml"))
				{
					Logger.LogDebug("Found color configuration: " + text);
					colorsFilePath = text;
					flag2 = true;
				}
				if (text.Contains("LootSettings.yaml"))
				{
					Logger.LogDebug("Found loot configuration: " + text);
					creatureLootFilePath = text;
					flag3 = true;
				}
				if (text.Contains("Modifiers.yaml"))
				{
					Logger.LogDebug("Found modifier configuration: " + text);
					creatureModifierFilePath = text;
					flag4 = true;
				}
				if (text.Contains("RaidSettings.yaml"))
				{
					Logger.LogDebug("Found raid configuration: " + text);
					raidsFilePath = text;
					flag5 = true;
				}
				if (text.Contains("NemesisSettings.yaml"))
				{
					Logger.LogDebug("Found nemesis configuration: " + text);
					nemesisFilePath = text;
					flag6 = true;
				}
			}
			if (!flag4)
			{
				Logger.LogDebug("Loot config missing, recreating.");
				using StreamWriter streamWriter = new StreamWriter(creatureModifierFilePath);
				string value = "#################################################\n# Star Level System Expanded - Creature Modifier Configuration\n#################################################\n";
				streamWriter.WriteLine(value);
				streamWriter.WriteLine(CreatureModifiersData.GetModifierDefaultConfig());
			}
			if (!flag3)
			{
				Logger.LogDebug("Loot config missing, recreating.");
				using StreamWriter streamWriter2 = new StreamWriter(creatureLootFilePath);
				string value2 = "#################################################\n# Star Level System Expanded - Creature loot configuration\n#################################################\n";
				streamWriter2.WriteLine(value2);
				streamWriter2.WriteLine(LootSystemData.YamlDefaultConfig());
			}
			if (!flag)
			{
				Logger.LogDebug("Level config file missing, recreating.");
				using StreamWriter streamWriter3 = new StreamWriter(levelsFilePath);
				string value3 = "#################################################\n# Star Level System Expanded - Level Settings\n#################################################\n";
				streamWriter3.WriteLine(value3);
				streamWriter3.WriteLine(LevelSystemData.YamlDefaultConfig());
			}
			if (!flag2)
			{
				Logger.LogDebug("Color config file missing, recreating.");
				using StreamWriter streamWriter4 = new StreamWriter(colorsFilePath);
				string value4 = "#################################################\n# Star Level System Expanded - Creature Level Color Settings\n#################################################\n";
				streamWriter4.WriteLine(value4);
				streamWriter4.WriteLine(Colorization.YamlDefaultConfig());
			}
			if (!flag5)
			{
				Logger.LogDebug("Raid config file missing, recreating.");
				using StreamWriter streamWriter5 = new StreamWriter(raidsFilePath);
				string value5 = "#################################################\n# Star Level System Expanded - Raid Settings\n#################################################\n";
				streamWriter5.WriteLine(value5);
				streamWriter5.WriteLine(RaidsData.YamlDefaultConfig());
			}
			if (!flag6)
			{
				Logger.LogDebug("Nemesis config file missing, recreating.");
				using StreamWriter streamWriter6 = new StreamWriter(nemesisFilePath);
				string value6 = "#################################################\n# Star Level System Expanded - Nemesis Settings\n#################################################\n";
				streamWriter6.WriteLine(value6);
				streamWriter6.WriteLine(NemesisSystemData.YamlDefaultConfig());
			}
			ConfigFileWatcher.Register(colorsFilePath, UpdateColorSettings);
			ConfigFileWatcher.Register(levelsFilePath, UpdateLevelSettings);
			ConfigFileWatcher.Register(creatureModifierFilePath, UpdateModifierSettings);
			ConfigFileWatcher.Register(creatureLootFilePath, UpdateLootSettings);
			ConfigFileWatcher.Register(raidsFilePath, UpdateRaidSettings);
			ConfigFileWatcher.Register(nemesisFilePath, UpdateNemesisSettings);
		}

		private static void UpdateColorSettings(string fullFileName)
		{
			Logger.LogDebug("Triggering Color Settings update.");
			Colorization.UpdateYamlConfig(File.ReadAllText(fullFileName));
			ColorSettingsRPC.SendPackage(ZNet.instance.m_peers, SendFileAsZPackage(fullFileName));
		}

		private static void UpdateLevelSettings(string fullFileName)
		{
			Logger.LogDebug("Triggering Level Settings update.");
			LevelSystemData.UpdateYamlConfig(File.ReadAllText(fullFileName));
			LevelSettingsRPC.SendPackage(ZNet.instance.m_peers, SendFileAsZPackage(fullFileName));
		}

		private static void UpdateLootSettings(string fullFileName)
		{
			Logger.LogDebug("Triggering Loot Settings update.");
			LootSystemData.UpdateYamlConfig(File.ReadAllText(fullFileName));
			CreatureLootSettingsRPC.SendPackage(ZNet.instance.m_peers, SendFileAsZPackage(fullFileName));
		}

		private static void UpdateModifierSettings(string fullFileName)
		{
			Logger.LogDebug("Triggering Modifiers Settings update.");
			CreatureModifiersData.UpdateModifierConfig(File.ReadAllText(fullFileName));
			ModifiersRPC.SendPackage(ZNet.instance.m_peers, SendFileAsZPackage(fullFileName));
		}

		private static void UpdateRaidSettings(string fullFileName)
		{
			Logger.LogDebug("Triggering Raid Settings update.");
			RaidsData.UpdateYamlConfig(File.ReadAllText(fullFileName));
			RaidsRPC.SendPackage(ZNet.instance.m_peers, SendFileAsZPackage(fullFileName));
		}

		private static void UpdateNemesisSettings(string fullFileName)
		{
			Logger.LogDebug("Triggering Nemesis Settings update.");
			NemesisSystemData.UpdateYamlConfig(File.ReadAllText(fullFileName));
			NemesisRPC.SendPackage(ZNet.instance.m_peers, SendFileAsZPackage(fullFileName));
		}

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

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

		private static ZPackage SendLevelsConfigs()
		{
			return SendFileAsZPackage(levelsFilePath);
		}

		private static ZPackage SendCreatureLootConfigs()
		{
			return SendFileAsZPackage(creatureLootFilePath);
		}

		private static ZPackage SendColorsConfigs()
		{
			return SendFileAsZPackage(colorsFilePath);
		}

		private static ZPackage SendModifierConfigs()
		{
			return SendFileAsZPackage(creatureModifierFilePath);
		}

		private static ZPackage SendRaidConfigs()
		{
			return SendFileAsZPackage(raidsFilePath);
		}

		private static ZPackage SendNemesisConfigs()
		{
			return SendFileAsZPackage(nemesisFilePath);
		}

		private static ZPackage SendRequestForPrivateKeys()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			return new ZPackage();
		}

		public static IEnumerator OnServerReceiveConfigs(long sender, ZPackage package)
		{
			Logger.LogDebug("Server received config from client, rejecting due to being the server.");
			yield return null;
		}

		public static IEnumerator OnServerReceivedNemesisBossAdd(long sender, ZPackage package)
		{
			ApplyNemesisBossAdd(package.ReadString(), sender);
			yield return null;
		}

		public static IEnumerator OnServerReceiveNemesisBossRemove(long sender, ZPackage package)
		{
			ApplyNemesisBossRemove(package.ReadString(), sender);
			yield return null;
		}

		internal static void ApplyNemesisBossAdd(string yaml, long senderToExclude)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			DataObjects.NemesisMiniboss item = DataObjects.yamlDeserializer.Deserialize<DataObjects.NemesisMiniboss>(yaml);
			NemesisSystemData.SLE_Nemesis_Settings.AvailableMiniBosses.Add(item);
			File.WriteAllText(nemesisFilePath, DataObjects.yamlSerializer.Serialize((object)NemesisSystemData.SLE_Nemesis_Settings));
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			ZPackage package = new ZPackage();
			package.Write(yaml);
			ZNet.instance.GetPeers().ForEach(delegate(ZNetPeer peer)
			{
				if (peer.m_uid != senderToExclude)
				{
					SendNewNemesisBossRPC.SendPackage(peer.m_uid, package);
				}
			});
		}

		internal static void ApplyNemesisBossRemove(string yaml, long senderToExclude)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			int num = FindMinibossIndex(yaml);
			if (num >= 0)
			{
				NemesisSystemData.SLE_Nemesis_Settings.AvailableMiniBosses.RemoveAt(num);
				File.WriteAllText(nemesisFilePath, DataObjects.yamlSerializer.Serialize((object)NemesisSystemData.SLE_Nemesis_Settings));
			}
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			ZPackage package = new ZPackage();
			package.Write(yaml);
			ZNet.instance.GetPeers().ForEach(delegate(ZNetPeer peer)
			{
				if (peer.m_uid != senderToExclude)
				{
					RemoveNemesisBossRPC.SendPackage(peer.m_uid, package);
				}
			});
		}

		private static int FindMinibossIndex(string yaml)
		{
			string target;
			try
			{
				target = DataObjects.yamlSerializer.Serialize((object)DataObjects.yamlDeserializer.Deserialize<DataObjects.NemesisMiniboss>(yaml));
			}
			catch
			{
				return -1;
			}
			return NemesisSystemData.SLE_Nemesis_Settings.AvailableMiniBosses.FindIndex((DataObjects.NemesisMiniboss b) => DataObjects.yamlSerializer.Serialize((object)b) == target);
		}

		private static ZPackage SendNemesisBossPins()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			List<DataObjects.NemesisBossPin> list = null;
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				list = NemesisRemoteSpawnControl.GetActiveBossPins();
			}
			val.Write(DataObjects.yamlSerializer.Serialize((object)(list ?? new List<DataObjects.NemesisBossPin>())));
			return val;
		}

		private static IEnumerator OnClientReceiveNemesisBossPinAdd(long sender, ZPackage package)
		{
			string text = package.ReadString();
			List<DataObjects.NemesisBossPin> list = null;
			try
			{
				list = DataObjects.yamlDeserializer.Deserialize<List<DataObjects.NemesisBossPin>>(text);
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to parse Nemesis boss pin add: " + ex.Message);
			}
			if (list != null)
			{
				foreach (DataObjects.NemesisBossPin item in list)
				{
					NemesisMinimap.AddOrUpdatePin(item);
				}
			}
			yield return null;
		}

		private static IEnumerator OnClientReceiveNemesisBossPinRemove(long sender, ZPackage package)
		{
			NemesisMinimap.RemovePin(package.ReadString());
			yield return null;
		}

		public static IEnumerator OnServerReceiveNemesisRemoteSpawnRequest(long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				if (!SenderIsAdmin(sender))
				{
					Logger.LogWarning($"Rejecting remote Nemesis spawn request from non-admin peer {sender}.");
					yield break;
				}
				Biome biome = (Biome)package.ReadInt();
				NemesisRemoteSpawnControl.Manager?.ForceSpawnForBiome(biome);
			}
			yield return null;
		}

		private static bool SenderIsAdmin(long sender)
		{
			ZNet instance = ZNet.instance;
			ZNetPeer val = ((instance != null) ? instance.GetPeer(sender) : null);
			if (val == null || val.m_socket == null)
			{
				return false;
			}
			return ZNet.instance.IsAdmin(val.m_socket.GetHostName());
		}

		public static IEnumerator OnServerReceiveNemesisBossDeath(long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				NemesisRemoteSpawnControl.RemoveActiveBoss(package.ReadString());
			}
			yield return null;
		}

		private static IEnumerator OnClientReceivePlaceNemesisSpawner(long sender, ZPackage package)
		{
			NemesisRemoteSpawnControl.InstantiateSpawnerFromRequest(package.ReadString());
			yield return null;
		}

		internal static void BroadcastNemesisBossPinAdd(DataObjects.NemesisBossPin pin)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (pin != null && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				ZPackage package = new ZPackage();
				package.Write(DataObjects.yamlSerializer.Serialize((object)new List<DataObjects.NemesisBossPin> { pin }));
				ZNet.instance.GetPeers().ForEach(delegate(ZNetPeer peer)
				{
					AddNemesisBossPinRPC.SendPackage(peer.m_uid, package);
				});
				NemesisMinimap.AddOrUpdatePin(pin);
			}
		}

		internal static void BroadcastNemesisBossPinRemove(string id)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			if (!string.IsNullOrEmpty(id) && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				ZPackage package = new ZPackage();
				package.Write(id);
				ZNet.instance.GetPeers().ForEach(delegate(ZNetPeer peer)
				{
					RemoveNemesisBossPinRPC.SendPackage(peer.m_uid, package);
				});
				NemesisMinimap.RemovePin(id);
			}
		}

		private static IEnumerator OnClientReceiveLevelConfigs(long sender, ZPackage package)
		{
			LevelSystemData.UpdateYamlConfig(package.ReadString());
			yield return null;
		}

		internal static IEnumerator NOOPReceive(long sender, ZPackage package)
		{
			yield break;
		}

		internal static IEnumerator OnServerReceiveZoneKills(long sender, ZPackage package)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				List<DataObjects.SerializableVector3> list = DataObjects.yamlDeserializer.Deserialize<List<DataObjects.SerializableVector3>>(package.ReadString());
				if (list != null)
				{
					ZoneScaleSystemData.ApplyDeaths(list);
					yield return null;
				}
			}
		}

		private static IEnumerator OnClientReceiveColorConfigs(long sender, ZPackage package)
		{
			Colorization.UpdateYamlConfig(package.ReadString());
			yield return null;
		}

		private static IEnumerator OnClientReceiveCreatureLootConfigs(long sender, ZPackage package)
		{
			LootSystemData.UpdateYamlConfig(package.ReadString());
			yield return null;
		}

		private static IEnumerator OnClientReceiveModifiersConfigs(long sender, ZPackage package)
		{
			CreatureModifiersData.UpdateModifierConfig(package.ReadString());
			yield return null;
		}

		private static IEnumerator OnClientReceiveMiniBossAdd(long sender, ZPackage package)
		{
			string text = package.ReadString();
			if (FindMinibossIndex(text) < 0)
			{
				NemesisSystemData.SLE_Nemesis_Settings.AvailableMiniBosses.Add(DataObjects.yamlDeserializer.Deserialize<DataObjects.NemesisMiniboss>(text));
			}
			yield return null;
		}

		private static IEnumerator OnClientReceiveMiniBossRemove(long sender, ZPackage package)
		{
			int num = FindMinibossIndex(package.ReadString());
			if (num >= 0)
			{
				NemesisSystemData.SLE_Nemesis_Settings.AvailableMiniBosses.RemoveAt(num);
			}
			yield return null;
		}

		private static IEnumerator OnClientReceiveRaidStart(long sender, ZPackage package)
		{
			string text = package.ReadString();
			DataObjects.NetworkRaidRequest networkRaidRequest = DataObjects.yamlDeserializer.Deserialize<DataObjects.NetworkRaidRequest>(text);
			Vector3 pos = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
			if ((Vector3)networkRaidRequest.RaidPostion != Vector3.zero)
			{
				pos = networkRaidRequest.RaidPostion;
			}
			RaidControl.StartRaidRunner(networkRaidRequest.Raid, pos);
			yield return null;
		}

		private static IEnumerator OnServerReceiveRaidCommitted(long sender, ZPackage package)
		{
			string raidName = package.ReadString();
			Vector3 pos = default(Vector3);
			((Vector3)(ref pos))..ctor(package.ReadSingle(), package.ReadSingle(), package.ReadSingle());
			RaidControl.FinalizeRaidCommit(((object)SLSExtensions.GetPlatformUserID(sender)/*cast due to .constrained prefix*/).ToString(), raidName, pos);
			yield break;
		}

		private static IEnumerator OnClientReceiveForcePlayMusic(long sender, ZPackage package)
		{
			string text = package.ReadString();
			if (!Enum.TryParse<DataObjects.Music>(text, out var result))
			{
				Logger.LogWarning("Music " + text + " not found.");
				yield break;
			}
			MusicMan.instance.TriggerMusic(result.ToString());
			yield return null;
		}

		private static IEnumerator OnClientReceiveForceRemoveNearbyEvents(long sender, ZPackage package)
		{
			RaidControl.RemoveNearbyRunningEvents();
			yield return null;
		}

		internal static IEnumerator OnClientReceiveRequestForPrivateKeys(long sender, ZPackage _)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				yield break;
			}
			List<string> privateKeysSanitize = Player.m_localPlayer.GetPrivateKeysSanitize();
			string text = DataObjects.yamlSerializerJsonCompat.Serialize((object)privateKeysSanitize);
			ZPackage val = new ZPackage();
			val.Write(text);
			if (string.IsNullOrEmpty(text) || privateKeysSanitize.Count <= 0)
			{
				Logger.LogDebug("No private keys received from player: " + ((Character)Player.m_localPlayer).m_name + ", skipping update to the server.");
				yield break;
			}
			if (ZNet.instance.GetServerPeer() != null && ZNet.instance.IsCurrentServerDedicated())
			{
				Logger.LogDebug("Sending private keys to server: " + text);
				ClientSendPlayerPrivateKeysRPC.SendPackage(ZNet.instance.GetServerPeer().m_uid, val);
				yield break;
			}
			Logger.LogDebug("Updating server with private keys: " + text);
			string localUserPlatformAndID = SLSExtensions.GetLocalUserPlatformAndID();
			if (string.IsNullOrEmpty(localUserPlatformAndID))
			{
				Logger.LogWarning("Could not update player private keys. Players platform was not detected.");
			}
			else
			{
				RaidControl.UpdateOrAddPlayerPrivateKeys(localUserPlatformAndID, privateKeysSanitize);
			}
		}

		private static IEnumerator OnServerReceivePlayerPrivateKeys(long sender, ZPackage package)
		{
			string text = package.ReadString();
			List<string> privatekeys = DataObjects.yamlDeserializer.Deserialize<List<string>>(text);
			RaidControl.UpdateOrAddPlayerPrivateKeys(sender, privatekeys);
			yield break;
		}

		private static IEnumerator OnClientReceiveRaidConfigs(long sender, ZPackage package)
		{
			RaidsData.UpdateYamlConfig(package.ReadString());
			yield return null;
		}

		private static IEnumerator OnClientReceiveNemesisConfigs(long sender, ZPackage package)
		{
			NemesisSystemData.UpdateYamlConfig(package.ReadString());
			yield return null;
		}

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

		public static string GetSavedDataSecondaryConfigDirectoryPath()
		{
			return Directory.CreateDirectory(Path.Combine(Paths.ConfigPath, "StarLevelSystem", "SavedData")).FullName;
		}

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

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

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

		public static ConfigEntry<string> BindServerConfig(string category, string key, string value, string description, AcceptableValueList<string> acceptableValues = null, bool advanced = false)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			return cfg.Bind<string>(category, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)acceptableValues, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true,
				IsAdvanced = advanced
			} }));
		}
	}
	internal static class ConfigFileWatcher
	{
		private class WatchEntry
		{
			public Action<string> Callback;

			public DateTime LastWriteUTC { get; set; }

			public long FileLength { get; set; }

			public void Update(DateTime lastwrite, long len)
			{
				LastWriteUTC = lastwrite;
				FileLength = len;
			}
		}

		internal class ConfigFileWatcherBehaviour : MonoBehaviour
		{
			private float nextPollTime;

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

			private static void Poll()
			{
				if (WatchedFiles.Count == 0)
				{
					return;
				}
				foreach (string key in WatchedFiles.Keys)
				{
					if (!File.Exists(key))
					{
						continue;
					}
					FileInfo fileInfo = new FileInfo(key);
					DateTime lastWriteTimeUtc = fileInfo.LastWriteTimeUtc;
					long length = fileInfo.Length;
					WatchEntry watchEntry = WatchedFiles[key];
					if (lastWriteTimeUtc == watchEntry.LastWriteUTC && length == watchEntry.FileLength)
					{
						continue;
					}
					WatchedFiles[key].LastWriteUTC = lastWriteTimeUtc;
					WatchedFiles[key].FileLength = length;
					try
					{
						if (watchEntry.Callback != null)
						{
							watchEntry.Callback(key);
						}
					}
					catch (Exception ex)
					{
						Logger.LogWarning("ConfigFileWatcher callback for " + key + " threw: " + ex.Message);
					}
				}
			}
		}

		private static Dictionary<string, WatchEntry> WatchedFiles = new Dictionary<string, WatchEntry>();

		private static ConfigFileWatcherBehaviour watchProcess;

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

		internal static void Register(string fullPath, Action<string> onChanged)
		{
			if (File.Exists(fullPath))
			{
				FileInfo fileInfo = new FileInfo(fullPath);
				DateTime lastWriteTimeUtc = fileInfo.LastWriteTimeUtc;
				long length = fileInfo.Length;
				WatchedFiles.Add(fullPath, new WatchEntry
				{
					LastWriteUTC = lastWriteTimeUtc,
					FileLength = length,
					Callback = onChanged
				});
			}
			else
			{
				WatchedFiles.Add(fullPath, new WatchEntry
				{
					LastWriteUTC = DateTime.MinValue,
					FileLength = 0L,
					Callback = onChanged
				});
			}
			Logger.LogDebug("ConfigFileWatcher watching " + fullPath);
		}
	}
	public class DataObjects
	{
		public enum CreatureBaseAttribute
		{
			BaseHealth,
			BaseDamage,
			AttackSpeed,
			Speed,
			Size
		}

		public enum CreaturePerLevelAttribute
		{
			HealthPerLevel,
			DamagePerLevel,
			SpeedPerLevel,
			AttackSpeedPerLevel,
			SizePerLevel
		}

		public enum DamageType
		{
			Blunt,
			Slash,
			Pierce,
			Fire,
			Frost,
			Lightning,
			Poison,
			Spirit,
			Chop,
			Pickaxe
		}

		public enum NameSelectionStyle
		{
			RandomFirst,
			RandomLast,
			RandomBoth
		}

		public enum VisualEffectStyle
		{
			objectCenter,
			top,
			bottom
		}

		public enum ModifierType
		{
			Major,
			Minor,
			Boss
		}

		public enum DropType
		{
			Tree,
			Rock,
			Destructible,
			None,
			Item
		}

		public enum LootFactorType
		{
			PerLevel,
			Exponential,
			ChancePerLevel
		}

		public enum DamageEstimateType
		{
			Average,
			Highest,
			Lowest
		}

		public enum AI
		{
			HuntPlayer,
			Alerted,
			AgitatedByBuild
		}

		public enum Music
		{
			Zrespawn,
			Zintro,
			Zmenu,
			Zcombat,
			ZCombatEventL1,
			ZCombatEventL2,
			ZCombatEventL3,
			ZCombatEventL4,
			Zboss_eikthyr,
			Zboss_gdking,
			Zboss_bonemass,
			Zboss_moder,
			Zboss_goblinking,
			Zboss_queen,
			Zboss_queen_ambience,
			Zboss_fader,
			Zmorning,
			Zevening,
			Zsailing,
			Zsailing_ashlands,
			Zblackforest,
			Zmeadows,
			Zswamp,
			Zmountain,
			Zplains,
			Zplainstower,
			Zmistlands,
			Zashlands,
			Zforestcrypt,
			Zforestcrypthildir,
			Zfrostcaves,
			Zfrostcaveshildir,
			Zhome,
			Zlocation_forest,
			Zlocation_haldor,
			Zlocation_dvergrtower,
			Zlocation_dvergrexc,
			Zlocation_ashlands_ruins
		}

		public enum Environment
		{
			Clear,
			Misty,
			Darklands_dark,
			DeepForest_Mist,
			Heath_clear,
			InfectedMine,
			GDKing,
			Rain,
			LightRain,
			ThunderStorm,
			Eikthyr,
			Fader,
			GoblinKing,
			nofogts,
			SwampRain,
			Bonemass,
			Snow,
			SnowStorm,
			Twilight_Clear,
			Twilight_Snow,
			Twilight_SnowStorm,
			Moder,
			Crypt,
			CryptHildir,
			Ghosts,
			Queen,
			SunkenCrypt,
			Mistlands_clear,
			Mistlands_rain,
			Mistlands_thunder,
			Ashlands_ashrain,
			Ashlands_ashrain_clear,
			Ashlands_CinderRain,
			Ashlands_meteorshower,
			Ashlands_misty,
			Ashlands_SeaStorm,
			Ashlands_storm,
			Caves,
			CavesHildir
		}

		public enum NemesisAction
		{
			ChangeLevel,
			AddModifier,
			RemoveModifier,
			Spawn,
			SpawnMiniboss
		}

		public enum ModifierDisplayStyle
		{
			Icons,
			Stars,
			None
		}

		public enum LevelupCalculationStyle
		{
			Gaussian,
			Exponential,
			Linear
		}

		public class DNum
		{
			private static readonly Dictionary<int, string> _enumReverseLookup = new Dictionary<int, string>();

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

			public DNum()
			{
			}

			public DNum(Array modnames)
			{
				foreach (int modname in modnames)
				{
					string name = Enum.GetName(typeof(CreatureModifiersData.ModifierNames), modname);
					_enumData[name] = modname;
					_enumReverseLookup[modname] = name;
				}
			}

			public DNum(Dictionary<string, int> initialValues)
			{
				Extensions.AddRange<string, int>(_enumData, initialValues);
				foreach (KeyValuePair<string, int> initialValue in initialValues)
				{
					_enumReverseLookup[initialValue.Value] = initialValue.Key;
				}
			}

			public void AddValue(string name, int id)
			{
				if (_enumData.ContainsKey(name))
				{
					Logger.LogWarning("Tried to add duplicate enum name " + name + " to DNum, skipping.");
				}
				_enumData[name] = id;
				_enumReverseLookup[id] = name;
			}

			[CanBeNull]
			public string GetValue(int id)
			{
				if (!_enumReverseLookup.TryGetValue(id, out var value))
				{
					return null;
				}
				return value;
			}

			public int GetValue(string name)
			{
				if (!_enumData.TryGetValue(name, out var value))
				{
					return -1;
				}
				return value;
			}

			public bool ContainsName(string name)
			{
				return _enumData.ContainsKey(name);
			}

			public bool ContainsID(int id)
			{
				return _enumReverseLookup.ContainsKey(id);
			}
		}

		public class LevelGenerator
		{
			public string PrefabName { get; set; }

			[DefaultValue(1)]
			public int MaxLevel { get; set; }

			[DefaultValue(1)]
			public int MinLevel { get; set; }

			[DefaultValue(0f)]
			public float LevelUpChance { get; set; }

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

			[DefaultValue(LevelupCalculationStyle.Linear)]
			public LevelupCalculationStyle LevelupCalculationStyle { get; set; } = LevelupCalculationStyle.Linear;

			[DefaultValue(0f)]
			public float GaussianOffset { get; set; }

			public SortedDictionary<int, float> GetLevelUpDefinition()
			{
				SortedDictionary<int, float> sortedDictionary = new SortedDictionary<int, float>();
				int num = MinLevel;
				int num2 = MaxLevel;
				if (num2 < num)
				{
					int num3 = num;
					num = num2;
					num2 = num3;
				}
				if (num2 == num)
				{
					sortedDictionary.Add(num, 0f);
					return sortedDictionary;
				}
				float num4 = Mathf.Clamp(LevelUpChance * 100f, 0.01f, 100f);
				int num5 = num2 - num;
				switch (LevelupCalculationStyle)
				{
				case LevelupCalculationStyle.Linear:
				{
					for (int j = num; j <= num2; j++)
					{
						float num8 = (float)(num2 - j) / (float)num5;
						float num9 = num4 * num8;
						sortedDictionary.Add(j, (j == num2) ? 0.01f : Mathf.Max(num9, 0.01f));
					}
					break;
				}
				case LevelupCalculationStyle.Gaussian:
				{
					float num10 = Mathf.Clamp(GaussianOffset, -1f, 1f);
					float num11 = Mathf.Max(0.05f, 1f - Mathf.Clamp01(LevelUpChance));
					double num12 = 2.0 * (double)num11 * (double)num11;
					int num13 = num5 + 1;
					double[] array = new double[num13];
					double num14 = 0.0;
					for (int k = 0; k < num13; k++)
					{
						float num15 = -1f + 2f * (float)k / (float)num5;
						num14 += (array[k] = Math.Exp((double)(0f - (num15 - num10) * (num15 - num10)) / num12));
					}
					double num16 = 0.0;
					for (int l = 0; l < num13; l++)
					{
						num16 += array[l] / num14;
						float num17 = (float)((1.0 - num16) * 100.0);
						int num18 = num + l;
						sortedDictionary.Add(num18, (num18 == num2) ? 0.01f : Mathf.Max(num17, 0.01f));
					}
					break;
				}
				default:
				{
					float num6 = Mathf.Pow(0.01f / num4, 1f / (float)num5);
					for (int i = num; i <= num2; i++)
					{
						float num7 = num4 * Mathf.Pow(num6, (float)(i - num));
						sortedDictionary.Add(i, (i == num2) ? 0.01f : Mathf.Max(num7, 0.01f));
					}
					break;
				}
				}
				return sortedDictionary;
			}

			public int RollAndDetermineLevel()
			{
				return LevelSelection.DetermineLevelRollResult(Random.Range(0f, 100f), MaxLevel, GetLevelUpDefinition(), new SortedDictionary<int, float>(), 1f, NightMultiplier);
			}
		}

		[Description("Per-biome conditional level generator, keyed under a defeated-boss global key.")]
		public class ConditionalLevelupChance
		{
			[Description("Level generators whose expanded curve replaces the biome default levelup chances when the owning boss is defeated.")]
			public List<LevelGenerator> LevelupGenerators { get; set; }

			[Description("Names of generator lists in CreatureLevelSettings.CustomLevelupGenerators to include alongside any inline LevelupGenerators.")]
			[DefaultValue(null)]
			public List<string> LevelupGeneratorRefs { get; set; }
		}

		[Description("Controls overhaul creature levels")]
		public class CreatureLevelSettings
		{
			[Description("Keyed lists of level generators that can be referenced elsewhere")]
			public Dictionary<string, List<LevelGenerator>> CustomLevelupGenerators { get; set; }

			[Description("Controls biome specific configuration, the 'All' biome can be used to set the default for everything.")]
			public Dictionary<Biome, BiomeSpecificSetting> BiomeConfiguration { get; set; }

			[Description("Creature specific configuration.")]
			public Dictionary<string, CreatureSpecificSetting> CreatureConfiguration { get; set; }

			[Description("Levelup chance for all creatures, this is modified by distance level bonuses and can be overridden by biome-specific settings or creature specific settings.")]
			public SortedDictionary<int, float> DefaultCreatureLevelUpChance { get; set; }

			[Description("Inline level generators whose expanded curve overwrites DefaultCreatureLevelUpChance on load. Merged with DefaultLevelupGeneratorRefs.")]
			[DefaultValue(null)]
			public List<LevelGenerator> DefaultLevelupGenerators { get; set; }

			[Description("Names of generator lists in CustomLevelupGenerators to include when building DefaultCreatureLevelUpChance. When any generators are present, the generated curve overwrites DefaultCreatureLevelUpChance.")]
			[DefaultValue(null)]
			public List<string> DefaultLevelupGeneratorRefs { get; set; }

			[Description("Globally disables the distance scaling system.")]
			public bool EnableDistanceLevelBonus { get; set; }

			[Description("Distance scaling system, each entry is a distance threshold and its corresponding level bonus. These are added to DefaultCreatureLevelUpChance, when a distance bucket is selected.")]
			public SortedDictionary<int, SortedDictionary<int, float>> DistanceLevelBonus { get; set; }

			[Description("Enables boss-reactive, biome-specific levelup chances based on the world's defeated bosses (global keys).")]
			public bool EnableConditionalCreatureLevelupChance { get; set; }

			[Description("Defeated-boss global key -> biome -> level generator. Highest tier (bottom-most listed) defeated boss applies; its generator replaces the biome default levelup curve and Min/Max. The 'All' biome acts as a fallback within an entry.")]
			public Dictionary<string, Dictionary<Biome, ConditionalLevelupChance>> ConditionalCreatureLevelupChance { get; set; }
		}

		[Description("Controls Night-time specific settings")]
		public class NightSettings
		{
			[Description("Modifies the spawn rate of creatures during the night time 1.0 = no change, 2.0 = 2x spawns, 0.5 = 50% reduced spawns.")]
			[DefaultValue(1f)]
			public float SpawnRateModifier { get; set; } = 1f;

			[Description("A level up chance scalar that is only applied at night. 1.0 = no change. 2.0 = all levels are 2x more likely (typically mostly impacts higher levels)")]
			[DefaultValue(1f)]
			public float NightLevelUpChanceScaler { get; set; } = 1f;

			[Description("Disables this creatures spawn during the night time.")]
			[DefaultValue(false)]
			public bool CreatureSpawnsDisabled { get; set; }
		}

		[Description("Controls biome-specific Night-time specific settings")]
		public class BiomeNightSettings
		{
			[Description("Modifies the spawn rate of creatures during the night time 1.0 = no change, 2.0 = 2x spawns, 0.5 = 50% reduced spawns.")]
			[DefaultValue(1f)]
			public float SpawnRateModifier { get; set; } = 1f;

			[Description("A level up chance scalar that is only applied at night. 1.0 = no change. 2.0 = all levels are 2x more likely (typically mostly impacts higher levels)")]
			[DefaultValue(1f)]
			public float NightLevelUpChanceScaler { get; set; } = 1f;

			[Description("Disables this creatures spawn during the night time.")]
			public List<string> CreatureSpawnsDisabled { get; set; } = new List<string>();
		}

		[Description("Biome specific settings.")]
		public class BiomeSpecificSetting
		{
			[Description("Custom creature levelup chances that will replace default chances for any creature spawned in this biome.")]
			public SortedDictionary<int, float> CustomCreatureLevelUpChance { get; set; }

			[Description("Inline level generators whose expanded curve overwrites this biome's CustomCreatureLevelUpChance on load. Merged with LevelupGeneratorRefs.")]
			public List<LevelGenerator> LevelupGenerators { get; set; }

			[Description("Names of generator lists in CreatureLevelSettings.CustomLevelupGenerators to include when building this biome's levelup chances. When any generators are present, the generated curve overwrites CustomCreatureLevelUpChance.")]
			public List<string> LevelupGeneratorRefs { get; set; }

			[Description("Minimum level override for creatures in this biome.")]
			[DefaultValue(0)]
			public int BiomeMinLevelOverride { get; set; }

			[Description("Maximum level override for creatures in this biome.")]
			public int BiomeMaxLevelOverride { get; set; }

			[Description("How strong distance effects are in this biome. 1.0 = no change, 2.0 = 2x stronger, 0.5 = 50% weaker.")]
			[DefaultValue(1f)]
			public float DistanceScaleModifier { get; set; } = 1f;

			[Description("Spawn rate modifier for creatures in this biome. 1.0 = no change, 2.0 = 2x spawns, 0.5 = 50% reduced spawns.")]
			[DefaultValue(1f)]
			public float SpawnRateModifier { get; set; } = 1f;

			[Description("Creature base value modifiers for all creatures spawned in this biome.")]
			public Dictionary<CreatureBaseAttribute, float> CreatureBaseValueModifiers { get; set; }

			[Description("Creature per-level value modifiers for all creatures spawned in this biome.")]
			public Dictionary<CreaturePerLevelAttribute, float> CreaturePerLevelValueModifiers { get; set; }

			[Description("Damage type and modifiers for all creatures spawned in this biome. This can be used to make creatures weak to, or immune to, certain damage types.")]
			[YamlMember(Alias = "DamageReceivedModifiers")]
			public Dictionary<DamageType, float> DamageRecievedModifiers { get; set; }

			[YamlMember(Alias = "DamageRecievedModifiers")]
			public Dictionary<DamageType, float> DamageRecievedModifiers_Legacy
			{
				get
				{
					return null;
				}
				set
				{
					DamageRecievedModifiers = value;
				}
			}

			[Description("List of creature spawns which are disabled in this biome.")]
			public List<string> CreatureSpawnsDisabled { get; set; }

			[Description("Night-time specific settings for this biome.")]
			public BiomeNightSettings NightSettings { get; set; }
		}

		[Description("Creature-specific settings.")]
		public class CreatureSpecificSetting
		{
			[Description("How strong distance effects are for this creature. 1.0 = no change, 2.0 = 2x stronger, 0.5 = 50% weaker.")]
			[DefaultValue(1f)]
			public float DistanceScaleModifier { get; set; } = 1f;

			[Description("Custom creature levelup chances that will replace default chances for this creature.")]
			public SortedDictionary<int, float> CustomCreatureLevelUpChance { get; set; }

			[Description("Inline level generators whose expanded curve overwrites this creature's CustomCreatureLevelUpChance on load. Merged with LevelupGeneratorRefs.")]
			public List<LevelGenerator> LevelupGenerators { get; set; }

			[Description("Names of generator lists in CreatureLevelSettings.CustomLevelupGenerators to include when building this creature's levelup chances. When any generators are present, the generated curve overwrites CustomCreatureLevelUpChance.")]
			public List<string> LevelupGeneratorRefs { get; set; }

			[Description("Creature specific minimum level.")]
			[DefaultValue(-1)]
			public int CreatureMinLevelOverride { get; set; } = -1;

			[Description("Creature specific maximum level.")]
			[DefaultValue(-1)]
			public int CreatureMaxLevelOverride { get; set; } = -1;

			[Description("Creature specific limit to the number of major modifiers.")]
			[DefaultValue(-1)]
			public int MaxMajorModifiers { get; set; } = -1;

			[Description("Creature specific chance for major modifiers.")]
			[DefaultValue(-1f)]
			public float ChanceForMajorModifier { get; set; } = -1f;

			[Description("Creature specific limit to the number of minor modifiers.")]
			[DefaultValue(-1)]
			public int MaxMinorModifiers { get; set; } = -1;

			[Description("Creature specific chance for minor modifiers.")]
			[DefaultValue(-1f)]
			public float ChanceForMinorModifier { get; set; } = -1f;

			[Description("Creature specific limit to the number of boss modifiers.")]
			[DefaultValue(-1)]
			public int MaxBossModifiers { get; set; } = -1;

			[Description("Creature specific chance for boss modifiers.")]
			[DefaultValue(-1f)]
			public float ChanceForBossModifier { get; set; } = -1f;

			[Description("Modifiers that this creature will always spawn with.")]
			public Dictionary<string, ModifierType> RequiredModifiers { get; set; }

			[Description("Spawn rate modifier for this creature. 1.0 = no change, 2.0 = 2x spawns, 0.5 = 50% reduced spawns.")]
			public float SpawnRateModifier { get; set; } = 1f;

			[Description("Night-time specific settings for this creature.")]
			public NightSettings NightSettings { get; set; }

			[Description("Base value modifiers for this creature.")]
			public Dictionary<CreatureBaseAttribute, float> CreatureBaseValueModifiers { get; set; }

			[Description("Per-level value modifiers for this creature.")]
			public Dictionary<CreaturePerLevelAttribute, float> CreaturePerLevelValueModifiers { get; set; }

			[Description("Damage received modifiers for this creature.")]
			[YamlMember(Alias = "DamageReceivedModifiers")]
			public Dictionary<DamageType, float> DamageRecievedModifiers { get; set; }

			[YamlMember(Alias = "DamageRecievedModifiers")]
			public Dictionary<DamageType, float> DamageRecievedModifiers_Legacy
			{
				get
				{
					return null;
				}
				set
				{
					DamageRecievedModifiers = value;
				}
			}
		}

		[DataContract]
		public class CreatureColorizationSettings
		{
			public Dictionary<string, Dictionary<int, ColorDef>> CharacterSpecificColorization { get; set; }

			public Dictionary<int, ColorDef> DefaultLevelColorization { get; set; }

			public Dictionary<string, List<ColorRangeDef>> CharacterColorGenerators { get; set; }
		}

		public class LootSettings
		{
			public Dictionary<string, List<ExtendedCharacterDrop>> CharacterSpecificLoot { get; set; }

			public Dictionary<string, List<ExtendedObjectDrop>> NonCharacterSpecificLoot { get; set; }

			public bool EnableDistanceLootModifier { get; set; }

			public SortedDictionary<int, DistanceLootModifier> DistanceLootModifier { get; set; }
		}

		public class LootEntry
		{
			public int Amount { get; set; }

			public GameObject Prefab { get; set; }

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

			public int ReferenceIndex { get; set; }
		}

		public class DistanceLootModifier
		{
			[DefaultValue(0f)]
			public float MinAmountScaleFactorBonus { get; set; }

			[DefaultValue(0f)]
			public float MaxAmountScaleFactorBonus { get; set; }

			[DefaultValue(0f)]
			public float ChanceScaleFactorBonus { get; set; }
		}

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

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

		public class CreatureModifierConfiguration
		{
			[DefaultValue(true)]
			public bool Enabled { get; set; } = true;

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

			public CreatureModConfig Config { get; set; } = new CreatureModConfig();

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

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

			public List<Biome> AllowedBiomes { get; set; }
		}

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

			public NameSelectionStyle NamingConvention { get; set; } = NameSelectionStyle.RandomBoth;

			public string NamePrefix { get; set; }

			public string NameSuffix { get; set; }

			public string StarVisual { get; set; }

			public string VisualEffect { get; set; }

			public string SecondaryEffect { get; set; }

			public VisualEffectStyle VisualEffectStyle { get; set; }

			public Delegate SetupEvent { get; set; }

			public Delegate RunOnceEvent { get; set; }

			public bool FromAPI { get; set; }

			public Sprite StarVisualAPI { get; set; }

			public GameObject VisualEffectAPI { get; set; }

			public GameObject SecondaryEffectAPI { get; set; }

			public void LoadAndSetGameObjects()
			{
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Expected O, but got Unknown
				if (FromAPI)
				{
					LoadAPIGameObjects();
					return;
				}
				if ((Object)(object)StarLevelSystem.EmbeddedResourceBundle == (Object)null)
				{
					Logger.LogDebug("Embedded asset bundle is unavailable; skipping modifier asset load.");
					return;
				}
				if (StarVisual != null && !CreatureModifiersData.LoadedModifierSprites.ContainsKey(StarVisual))
				{
					string text = "assets/custom/starlevels/icons/" + StarVisual + ".png";
					if (CreatureModifiersData.SelectedModifierDisplayStyle == ModifierDisplayStyle.Stars)
					{
						text = "assets/custom/starlevels/icons2/" + StarVisual + ".png";
					}
					Sprite value = StarLevelSystem.EmbeddedResourceBundle.LoadAsset<Sprite>(text);
					CreatureModifiersData.LoadedModifierSprites.Add(StarVisual, value);
				}
				if (VisualEffect != null && !CreatureModifiersData.LoadedModifierEffects.ContainsKey(VisualEffect))
				{
					CustomPrefab val = new CustomPrefab(StarLevelSystem.EmbeddedResourceBundle.LoadAsset<GameObject>(VisualEffect), true);
					PrefabManager.Instance.AddPrefab(val);
					GameObject prefab = PrefabManager.Instance.GetPrefab(VisualEffect);
					CreatureModifiersData.LoadedModifierEffects.Add(VisualEffect, prefab);
				}
				if (SecondaryEffect != null && !CreatureModifiersData.LoadedSecondaryEffects.ContainsKey(SecondaryEffect))
				{
					CustomPrefab val2 = new CustomPrefab(StarLevelSystem.EmbeddedResourceBundle.LoadAsset<GameObject>(SecondaryEffect), true);
					PrefabManager.Instance.AddPrefab(val2);
					GameObject prefab2 = PrefabManager.Instance.GetPrefab(SecondaryEffect);
					CreatureModifiersData.LoadedSecondaryEffects.Add(SecondaryEffect, prefab2);
				}
			}

			public void LoadAPIGameObjects()
			{
				if ((Object)(object)StarVisualAPI != (Object)null && !CreatureModifiersData.LoadedModifierSprites.ContainsKey(StarVisual))
				{
					CreatureModifiersData.LoadedModifierSprites.Add(StarVisual, StarVisualAPI);
				}
				if ((Object)(object)VisualEffectAPI != (Object)null && !CreatureModifiersData.LoadedModifierEffects.ContainsKey(VisualEffect))
				{
					CreatureModifiersData.LoadedModifierEffects.Add(VisualEffect, VisualEffectAPI);
				}
				if ((Object)(object)SecondaryEffectAPI != (Object)null && !CreatureModifiersData.LoadedSecondaryEffects.ContainsKey(SecondaryEffect))
				{
					CreatureModifiersData.LoadedSecondaryEffects.Add(SecondaryEffect, SecondaryEffectAPI);
				}
			}

			public void RunOnceMethodCall(Character chara, CreatureModConfig cfg, CharacterCacheEntry scd)
			{
				if ((object)RunOnceEvent != null)
				{
					RunOnceEvent.DynamicInvoke(chara, cfg, scd);
				}
			}

			public void SetupMethodCall(Character chara, CreatureModConfig cfg, CharacterCacheEntry scd)
			{
				if ((object)SetupEvent != null)
				{
					SetupEvent.DynamicInvoke(chara, cfg, scd);
				}
			}
		}

		public class CreatureModConfig
		{
			public float PerlevelPower { get; set; }

			public float BasePower { get; set; }

			public Dictionary<Biome, List<string>> BiomeObjects { get; set; }

			public Dictionary<string, float> Config { get; set; }
		}

		public class CreatureModifierCollection
		{
			public GlobalModifierSettings ModifierGlobalSettings { get; set; } = new GlobalModifierSettings();

			public Dictionary<string, CreatureModifierConfiguration> MajorModifiers { get; set; }

			public Dictionary<string, CreatureModifierConfiguration> MinorModifiers { get; set; }

			public Dictionary<string, CreatureModifierConfiguration> BossModifiers { get; set; }
		}

		public class GlobalModifierSettings
		{
			public List<string> GlobalIgnorePrefabList = new List<string>();
		}

		public class PlayerRaidData
		{
			public RaidDefinition ActiveRaid { get; set; }

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

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

			public double NextRaidableTime { get; set; }

			public SerializableVector3 CurrentRaidPosition { get; set; }

			public Dictionary<string, double> LastRaidByName { get; set; } = new Dictionary<string, double>();
		}

		public class PlayerPrivatekeys
		{
			public List<string> PrivateKeys { get; set; } = new List<string>();

			public double LastUpdatedAt { get; set; }
		}

		public class PlayerRaidHistory
		{
			public double NextRaidableTime { get; set; }

			public Dictionary<string, double> LastRaidByName { get; set; }
		}

		public class RaidConfiguration
		{
			public GlobalRaidSettings GlobalSettings { get; set; } = new GlobalRaidSettings();

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

		public class GlobalRaidSettings
		{
			[DefaultValue(false)]
			public bool DisableAllRaids { get; set; }

			[DefaultValue(true)]
			public bool PlayerBasedRaids { get; set; } = true;

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

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

		public class NetworkRaidRequest
		{
			public SerializableVector3 RaidPostion { get; set; } = Vector3.zero;

			public RaidDefinition Raid { get; set; }
		}

		public class NemesisRemotePlacementRequest
		{
			public NemesisMiniboss Boss { get; set; }

			public int Biome { get; set; }

			public string PinId { get; set; }

			public string BossName { get; set; }

			public SerializableVector3 PlacePos { get; set; } = Vector3.zero;
		}

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

			[DefaultValue(true)]
			public bool Enabled { get; set; } = true;

			[DefaultValue(60f)]
			public float Duration { get; set; } = 60f;

			[DefaultValue(true)]
			public bool RaidActiveTillDefeated { get; set; } = true;

			[DefaultValue(12)]
			public int SpawnPoints { get; set; } = 12;

			public float RaidCoolDownMinutes { get; set; } = 120f;

			public RaidActivation Activation { get; set; } = new RaidActivation();

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

			[DefaultValue(96f)]
			public float EventRange { get; set; } = 96f;

			[DefaultValue("")]
			public string StartMessage { get; set; } = "";

			[DefaultValue("")]
			public string EndMessage { get; set; } = "";

			[DefaultValue(Environment.Clear)]
			public Environment ForceEnvironment { get; set; }

			[DefaultValue(Music.Zcombat)]
			public Music ForceMusic { get; set; } = Music.Zcombat;

			public RandomEvent ToRaid(Vector3 position)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				RandomEvent val = new RandomEvent
				{
					m_name = Name,
					m_duration = Duration
				};
				if (Activation != null)
				{
					if (Activation.RequiredGlobalKeys != null)
					{
						val.m_requiredGlobalKeys = Activation.RequiredGlobalKeys;
					}
					if (Activation.NotRequiredGlobalKeys != null)
					{
						val.m_notRequiredGlobalKeys = Activation.NotRequiredGlobalKeys;
					}
					if (Activation.RequiredPlayerKeys != null)
					{
						val.m_altRequiredPlayerKeysAll = Activation.RequiredPlayerKeys;
					}
					if (Activation.NotRequiredPlayerKeys != null)
					{
						val.m_altNotRequiredPlayerKeys = Activation.NotRequiredPlayerKeys;
					}
					if (Activation.AnyRequiredPlayerKeys != null)
					{
						val.m_altRequiredPlayerKeysAny = Activation.AnyRequiredPlayerKeys;
					}
					val.m_standaloneChance = Activation.Chance;
					val.m_standaloneInterval = 100f;
					val.m_pauseIfNoPlayerInArea = Activation.PauseIfNoPlayerInArea;
					val.m_nearBaseOnly = Activation.NearBaseOnly;
				}
				val.m_spawnerDelay = 0f;
				val.m_eventRange = EventRange;
				val.m_startMessage = Localization.instance.Localize(StartMessage);
				val.m_endMessage = Localization.instance.Localize(EndMessage);
				val.m_forceEnvironment = ForceEnvironment.ToString();
				val.m_biome = Heightmap.FindBiome(position);
				val.m_forceMusic = ForceMusic.ToString();
				val.m_random = true;
				val.m_time = 0f;
				val.m_pos = position;
				return val;
			}
		}

		[Serializable]
		public class RaidActivation
		{
			public List<Biome> Biomes { get; set; }

			[DefaultValue(true)]
			public bool NearBaseOnly { get; set; }

			[DefaultValue(true)]
			public bool PauseIfNoPlayerInArea { get; set; } = true;

			[DefaultValue(100f)]
			public float Chance { get; set; } = 100f;

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

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

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

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

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

		[Serializable]
		public class RaidSpawnEntry
		{
			public string PrefabName { get; set; }

			public AI CreatureAI { get; set; } = AI.Alerted;

			[DefaultValue(10f)]
			public float SpawnInterval { get; set; } = 10f;

			[DefaultValue(100f)]
			public float SpawnChance { get; set; } = 100f;

			[DefaultValue(0f)]
			public float InitalSpawnDelay { get; set; }

			[DefaultValue(0)]
			public int MaxSpawned { get; set; }

			[DefaultValue(0)]
			public int MaxSpawnTriggers { get; set; }

			[DefaultValue(1)]
			public int SpawnGroupSize { get; set; } = 1;

			[DefaultValue(/*Could not decode attribute arguments.*/)]
			public Faction Faction { get; set; } = (Faction)12;

			[DefaultValue(1)]
			public int LevelMin { get; set; } = 1;

			public int LevelMax { get; set; } = ValConfig.MaxLevel.Value;

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

			public Dictionary<string, ModifierType> RequiredModifiers { get; set; }

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

			[DefaultValue(null)]
			public SortedDictionary<int, float> CustomCreatureLevelUpChance { get; set; }

			[DefaultValue(null)]
			public List<LevelGenerator> LevelupGenerators { get; set; }

			[DefaultValue(null)]
			public List<string> LevelupGeneratorRefs { get; set; }
		}

		[Serializable]
		public class RaidMonitor
		{
			public RaidSpawnEntry RaidSpawnDef { get; set; }

			public double NextSpawn { get; set; }

			[DefaultValue(0)]
			public int TriggerCount { get; set; }

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

			public List<ZDOID> GetSpawnedZDOIDs()
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				List<ZDOID> list = new List<ZDOID>();
				foreach (string spawnedCreature in SpawnedCreatures)
				{
					string[] array = spawnedCreature.Split(new char[1] { ':' });
					list.Add(new ZDOID(long.Parse(array[0]), uint.Parse(array[1])));
				}
				return list;
			}

			public unsafe void StoreZDOIDS(List<ZDOID> connected)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				SpawnedCreatures.Clear();
				foreach (ZDOID item in connected)
				{
					SpawnedCreatures.Add(((object)(*(ZDOID*)(&item))/*cast due to .constrained prefix*/).ToString());
				}
			}
		}

		public class NemesisConfiguration
		{
			public Dictionary<Biome, List<NemesisMinion>> NemesisMinionTemplatesByBiome = new Dictionary<Biome, List<NemesisMinion>>();

			public int NemesisVersion { get; set; }

			[DefaultValue(10f)]
			public float NemesisActionCooldownSeconds { get; set; } = 10f;

			[DefaultValue(300f)]
			public float NemesisInfluenceRadius { get; set; } = 300f;

			public float NemesisMinSpawnDistance { get; set; } = 20f;

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

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

			public float NemesisBossChance { get; set; } = 0.1f;

			public float NemesisBossMaxLevelBonus { get; set; } = 0.4f;

			public float NemesisBossMinLevelBonus { get; set; } = 0.2f;

			public NemesisScore ScoreSystem { get; set; } = new NemesisScore();

			public NemesisGaurenteedChanges GaurenteedChanges { get; set; } = new NemesisGaurenteedChanges();

			public NemesisChanceChanges ChanceChanges { get; set; } = new NemesisChanceChanges();

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

			[Description("Server-driven ambient remote spawning of Nemesis minibosses across the world.")]
			public RemoteNemesisSpawnSettings RemoteSpawning { get; set; } = new RemoteNemesisSpawnSettings();

			[Description("Biome-keyed extra loot granted to remotely-spawned Nemesis bosses and their minions. Merged onto each creature's per-instance loot table.")]
			public Dictionary<Biome, List<ExtendedCharacterDrop>> NemesisBossLootTables { get; set; } = new Dictionary<Biome, List<ExtendedCharacterDrop>>();
		}

		public class RemoteNemesisSpawnSettings
		{
			[Description("Enables remote spawning. Also gated by the 'EnableNemesisRemoteSpawning' server config.")]
			[DefaultValue(true)]
			public bool Enabled { get; set; } = true;

			[Description("Minutes between server checks that scout and place remote bosses.")]
			[DefaultValue(30f)]
			public float CheckIntervalMinutes { get; set; } = 30f;

			[Description("Maximum number of new remote bosses that can be placed in a single interval.")]
			[DefaultValue(3)]
			public int MaxSpawnsPerInterval { get; set; } = 3;

			[Description("Maximum number of live remote bosses server-wide across all biomes.")]
			[DefaultValue(10)]
			public int MaxConcurrentTotal { get; set; } = 10;

			[Description("Desired number of live remote bosses to maintain per biome.")]
			public Dictionary<Biome, int> TargetPerBiome { get; set; }

			[Description("Maximum number of live remote bosses allowed per biome.")]
			public Dictionary<Biome, int> MaxConcurrentPerBiome { get; set; }

			[Description("World-distance band (from world center) used when scouting a spawn point for each biome.")]
			public Dictionary<Biome, BiomeSpawnRadius> BiomeRadiusRanges { get; set; }

			[Description("NemesisSpawn boss archetypes generated per biome when the AvailableMiniBosses pool has no biome-appropriate entry. Weighted by SelectionWeight; level comes from ForcedLevel/LevelupGenerators.")]
			public Dictionary<Biome, List<NemesisSpawn>> BossCandidatesByBiome { get; set; }

			[Description("Show a map pin at each remote boss location.")]
			[DefaultValue(true)]
			public bool ShowMapPin { get; set; } = true;

			[Description("Radius (meters) of the red circular EventArea overlay drawn under each boss pin.")]
			[DefaultValue(60f)]
			public float MapPinAreaRadius { get; set; } = 60f;

			[Description("Name of the pin sprite in the embedded asset bundle. Empty uses the fallback vanilla pin type.")]
			[DefaultValue("")]
			public string MapPinSpriteAsset { get; set; } = "";

			[Description("Vanilla pin type used when no custom sprite is configured or the sprite is missing.")]
			[DefaultValue(/*Could not decode attribute arguments.*/)]
			public PinType FallbackPinType { get; set; } = (PinType)9;

			[Description("Label the map pin with the boss name.")]
			[DefaultValue(true)]
			public bool PinShowsBossName { get; set; } = true;
		}

		public class BiomeSpawnRadius
		{
			public float Min { get; set; }

			public float Max { get; set; }
		}

		public class NemesisMinion
		{
			public string PrefabName { get; set; }

			public int MinAmount { get; set; }

			public int MaxAmount { get; set; }

			public Dictionary<CreatureBaseAttribute, float> CreatureBaseValueModifiers { get; set; }

			public Dictionary<CreaturePerLevelAttribute, float> CreaturePerLevelValueModifiers { get; set; }
		}

		public class NemesisChanceChanges
		{
			public Dictionary<string, NemesisChanceEntry> CreatureOps { get; set; } = new Dictionary<string, NemesisChanceEntry>();
		}

		public class NemesisChanceEntry
		{
			public List<string> RequiredGlobalKeys { get; set; }

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

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

			[DefaultValue(true)]
			public bool Enabled { get; set; } = true;

			[DefaultValue(0.5f)]
			public float Chance { get; set; } = 0.5f;

			[DefaultValue(0)]
			public int LevelBonus { get; set; }

			public List<Biome> DeniedBiomes { get; set; } = new List<Biome> { (Biome)0 };

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

			[DefaultValue(0f)]
			public float ScoreThreshold { get; set; }

			public NemesisAction Action { get; set; }

			[DefaultValue(0f)]
			public float ScoreChange { get; set; }

			public float ExtraCooldownSeconds { get; set; }

			public List<NemesisSpawn> SpawnConfig { get; set; }

			public NemesisPlayerStateRequirements PlayerReqs { get; set; }
		}

		public class NemesisPlayerStateRequirements
		{
			[DefaultValue(/*Could not decode attribute arguments.*/)]
			public Biome PlayerCurrentBiome { get; set; }

			[DefaultValue(0)]
			public int MinBiomeHistory { get; set; }

			[DefaultValue(0f)]
			public float PlayerHealthPercentAbove { get; set; }

			public float PlayerHealthPercentBelow { get; set; }
		}

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

			public AI CreatureAI { get; set; }

			[DefaultValue(0)]
			public int ForcedLevel { get; set; }

			[DefaultValue(null)]
			public List<LevelGenerator> LevelupGenerators { get; set; }

			[DefaultValue(null)]
			public List<string> LevelupGeneratorRefs { get; set; }

			[DefaultValue(false)]
			public bool DespawnIfNotAlerted { get; set; }

			[DefaultValue(false)]
			public bool IsBoss { get; set; }

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

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

			[DefaultValue("")]
			public string CustomName { get; set; } = "";

			[DefaultValue(/*Could not decode attribute arguments.*/)]
			public Faction Faction { get; set; } = (Faction)12;

			[DefaultValue(null)]
			public Dictionary<string, ModifierType> RequiredModifiers { get; set; }

			public Dictionary<CreatureBaseAttribute, float> CreatureBaseValueModifiers { get; set; }

			public Dictionary<CreaturePerLevelAttribute, float> CreaturePerLevelValueModifiers { get; set; }

			[DefaultValue(null)]
			public List<ExtendedCharacterDrop> CustomLoot { get; set; }
		}

		public class NemesisMiniboss
		{
			public bool BossCreatedFromKillingPlayer { get; set; }

			public string KilledPlayerName { get; set; }

			public NemesisSpawn BossSpawn { get; set; }

			public List<NemesisSpawn> Minions { get; set; }

			public Biome Biome { get; set; }
		}

		public class NemesisGaurenteedChanges
		{
			public bool FirstBossSetLevel { get; set; } = true;

			public int FirstBossLevel { get; set; }
		}

		public class NemesisBossPin
		{
			public string Id { get; set; }

			public SerializableVector3 Position { get; set; }

			public Biome Biome { get; set; }

			public string Name { get; set; }
		}

		public class NemesisScore
		{
			[DefaultValue(0f)]
			public float NeutralScore { get; set; } = 600f;

			[DefaultValue(0f)]
			public float MinScore { get; set; }

			[DefaultValue(0f)]
			public float MaxScore { get; set; } = 1000f;

			[DefaultValue(500f)]
			public float DeathScoreReduction { get; set; } = 500f;

			[DefaultValue(30f)]
			public float DecayPerUpdate { get; set; } = 30f;

			[DefaultValue(30f)]
			public float ScoreIntervalSeconds { get; set; } = 30f;

			[DefaultValue(25f)]
			public float NearbyPlayerRadius { get; set; } = 25f;

			[DefaultValue(0.05f)]
			public float NearbyAveragingWeight { get; set; } = 0.05f;

			[DefaultValue(0.5f)]
			public float MeleeDamageDealtFactor { get; set; } = 0.5f;

			[DefaultValue(0.25f)]
			public float RangedDamageDealtFactor { get; set; } = 0.25f;

			[DefaultValue(0.3f)]
			public float MagicDamageDealtFactor { get; set; } = 0.3f;

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

			[DefaultValue(250f)]
			public float BossKillBonus { get; set; } = 250f;

			[DefaultValue(100f)]
			public float BossKillRadius { get; set; } = 100f;

			[DefaultValue(5f)]
			public int RecentBiomeHistoryLength { get; set; } = 5;

			[DefaultValue(3)]
			public int DamageScoreHistoryLength { get; set; } = 3;
		}

		[Serializable]
		public class ScoreData
		{
			public float DamageDealtMelee { get; set; }

			public float DamageDealtRanged { get; set; }

			public float DamageDealtMagic { get; set; }

			public float DamageTaken { get; set; }

			public int BossKills { get; set; }

			public Dictionary<string, int> BossKillsHistory { get; set; } = new Dictionary<string, int>();

			public double LastDeath { get; set; }

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

		[Serializable]
		public class DamageScoreData
		{
			public float DamageDealtMelee { get; set; }

			public float DamageDealtRanged { get; set; }

			public float DamageDealtMagic { get; set; }

			public float DamageTaken { get; set; }

			public int BossKills { get; set; }
		}

		[Serializable]
		public class CharacterCacheEntry
		{
			public int Level { get; set; }

			public ZDO ZDO { get; set; }

			public bool ShouldDelete { get; set; }

			public string CreatureNameLocalizable { get; set; }

			public string RefCreatureName { get; set; }

			public ColorDef Colorization { get; set; }

			public Biome Biome { get; set; }

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

			public bool RunOnceDone { get; set; }

			public Dictionary<string, ModifierType> CreatureModifiers { get; set; } = new Dictionary<string, ModifierType>();

			public Dictionary<string, ModifierType> ModifiersRequired { get; set; }

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

			public Dictionary<DamageType, float> DamageRecievedModifiers { get; set; } = new Dictionary<DamageType, float>
			{
				{
					DamageType.Blunt,
					1f
				},
				{
					DamageType.Pierce,
					1f
				},
				{
					DamageType.Slash,
					1f
				},
				{
					DamageType.Fire,
					1f
				},
				{
					DamageType.Frost,
					1f
				},
				{
					DamageType.Lightning,
					1f
				},
				{
					DamageType.Poison,
					1f
				},
				{
					DamageType.Spirit,
					1f
				},
				{
					DamageType.Chop,
					1f
				},
				{
					DamageType.Pickaxe,
					1f
				}
			};

			public Dictionary<CreatureBaseAttribute, float> CreatureBaseValueModifiers { get; set; } = new Dictionary<CreatureBaseAttribute, float>
			{
				{
					CreatureBaseAttribute.BaseDamage,
					1f
				},
				{
					CreatureBaseAttribute.BaseHealth,
					1f
				},
				{
					CreatureBaseAttribute.Size,
					1f
				},
				{
					CreatureBaseAttribute.Speed,
					1f
				},
				{
					CreatureBaseAttribute.AttackSpeed,
					1f
				}
			};

			public Dictionary<CreaturePerLevelAttribute, float> CreaturePerLevelValueModifiers { get; set; } = new Dictionary<CreaturePerLevelAttribute, float>
			{
				{
					CreaturePerLevelAttribute.DamagePerLevel,
					0f
				},
				{
					CreaturePerLevelAttribute.HealthPerLevel,
					0f
				},
				{
					CreaturePerLevelAttribute.SizePerLevel,
					0f
				},
				{
					CreaturePerLevelAttribute.SpeedPerLevel,
					0f
				},
				{
					CreaturePerLevelAttribute.AttackSpeedPerLevel,
					0f
				}
			};

			public CreatureSpecificSetting CreatureSettings { get; set; }

			public Dictionary<DamageType, float> CreatureDamageBonus { get; set; } = new Dictionary<DamageType, float>();

			public string GetDamageBonusDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				foreach (KeyValuePair<DamageType, float> creatureDamageBonu in CreatureDamageBonus)
				{
					if (creatureDamageBonu.Value > 0f)
					{
						stringBuilder.Append($"|{creatureDamageBonu.Key}-{creatureDamageBonu.Value}");
					}
				}
				return stringBuilder.ToString();
			}
		}

		[DataContract]
		public class ExtendedCharacterDrop
		{
			public Drop Drop { get; set; }

			public Drop GameDrop { get; private set; }

			[DefaultValue(0f)]
			public float AmountScaleFactor { get; set; }

			[DefaultValue(0f)]
			public float ChanceScaleFactor { get; set; }

			public bool UseChanceAsMultiplier { get; set; }

			public bool ScalebyMaxLevel { get; set; }

			public bool DoesNotScale { get; set; }

			[DefaultValue(0)]
			public int MaxScaledAmount { get; set; }

			public bool UntamedOnlyDrop { get; set; }

			public bool TamedOnlyDrop { get; set; }

			public void ToCharacterDrop()
			{
				GameDrop = Drop.ToCharDrop();
			}
		}

		[DataContract]
		public class ExtendedObjectDrop
		{
			public Drop Drop { get; set; }

			public GameObject DropGo { get; private set; }

			public float AmountScaleFactor { get; set; }

			[DefaultValue(0f)]
			public float ChanceScaleFactor { get; set; }

			public bool UseChanceAsMultiplier { get; set; }

			[DefaultValue(0)]
			public int MaxScaledAmount { get; set; }

			public void ResolveDropPrefab()
			{
				DropGo = PrefabManager.Instance.GetPrefab(Drop.Prefab);
			}
		}

		[DataContract]
		public class Drop
		{
			public string Prefab { get; set; }

			[DefaultValue(1)]
			public int Min { get; set; } = 1;

			[DefaultValue(1)]
			public int Max { get; set; } = 1;

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

			[DefaultValue(false)]
			public bool OnePerPlayer { get; set; }

			[DefaultValue(true)]
			public bool LevelMultiplier { get; set; } = true;

			[DefaultValue(false)]
			public bool DontScale { get; set; }

			public Drop ToCharDrop()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				return new Drop
				{
					m_prefab = PrefabManager.Instance.GetPrefab(Prefab),
					m_amountMin = Min,
					m_amountMax = Max,
					m_chance = Chance,
					m_onePerPlayer = OnePerPlayer,
					m_levelMultiplier = LevelMultiplier,
					m_dontScale = DontScale
				};
			}
		}

		[Serializable]
		[DataContract]
		public class ColorDef
		{
			public float Hue { get; set; }

			public float Saturation { get; set; }

			public float Value { get; set; }

			public bool IsEmissive { get; set; }

			public ColorDef()
			{
			}

			public ColorDef(float hue = 0f, float saturation = 0f, float value = 0f, bool is_emissive = false)
			{
				Hue = hue;
				Saturation = saturation;
				Value = value;
				IsEmissive = is_emissive;
			}

			public LevelSetup ToLevelEffect()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				return new LevelSetup
				{
					m_scale = 1f,
					m_hue = Hue,
					m_saturation = Saturation,
					m_value = Value,
					m_setEmissiveColor = IsEmissive,
					m_emissiveColor = new Color(Hue, Saturation, Value)
				};
			}
		}

		[DataContract]
		public class ColorRangeDef
		{
			[DefaultValue(true)]
			public bool CharacterSpecific { get; set; } = true;

			[DefaultValue(false)]
			public bool OverwriteExisting { get; set; }

			public ColorDef StartColorDef { get; set; }

			public ColorDef EndColorDef { get; set; }

			public int RangeStart { get; set; }

			public int RangeEnd { get; set; }
		}

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

			public string Key { get; private set; }

			public T DefaultValue { get; private set; }

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

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

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

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

			public abstract T Get();

			protected abstract void SetValue(T value);
		}

		[Serializable]
		public struct SerializableVector3
		{
			public float x;

			public float y;

			public float z;

			public SerializableVector3(float rX, float rY, float rZ)
			{
				x = rX;
				y = rY;
				z = rZ;
			}

			public override readonly string ToString()
			{
				return $"[{x}, {y}, {z}]";
			}

			public static implicit operator Vector3(SerializableVector3 rValue)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				return new Vector3(rValue.x, rValue.y, rValue.z);
			}

			public static implicit operator SerializableVector3(Vector3 rValue)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				return new SerializableVector3(rValue.x, rValue.y, rValue.z);
			}
		}

		public class ListStringZNetProperty : ZNetProperty<List<string>>
		{
			private readonly BinaryFormatter binFormatter = new BinaryFormatter();

			public ListStringZNetProperty(string key, ZNetView zNetView, List<string> defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}

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

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

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

			public override Dictionary<string, ModifierType> Get()
			{
				byte[] byteArray = zNetView.GetZDO().GetByteArray(base.Key, (byte[])null);
				if (byteArray == null)
				{
					return new Dictionary<string, ModifierType>();
				}
				MemoryStream serializationStream = new MemoryStream(byteArray);
				Dictionary<int, ModifierType> obj = (Dictionary<int, ModifierType>)binFormatter.Deserialize(serializationStream);
				Dictionary<string, ModifierType> dictionary = new Dictionary<string, ModifierType>();
				foreach (KeyValuePair<int, ModifierType> item in obj)
				{
					string value = CreatureModifiersData.ModifierNamesLookupTable.GetValue(item.Key);
					if (value != null)
					{
						dictionary.Add(value, item.Value);
					}
				}
				return dictionary;
			}

			protected override void SetValue(Dictionary<string, ModifierType> value)
			{
				Dictionary<int, ModifierType> dictionary = new Dictionary<int, ModifierType>();
				foreach (KeyValuePair<string, ModifierType> item in value)
				{
					int value2 = CreatureModifiersData.ModifierNamesLookupTable.GetValue(item.Key);
					if (value2 != -1)
					{
						dictionary.Add(value2, item.Value);
					}
				}
				MemoryStream memoryStream = new MemoryStream();
				binFormatter.Serialize(memoryStream, dictionary);
				zNetView.GetZDO().Set(base.Key, memoryStream.ToArray());
			}
		}

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

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

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

		public class ListModifierZNetProperty : ZNetProperty<List<CreatureModifiersData.ModifierNames>>
		{
			public ListModifierZNetProperty(string key, ZNetView zNetView, List<CreatureModifiersData.ModifierNames> defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}

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

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

		public class DictionaryDmgNetProperty : ZNetProperty<Dictionary<DamageType, float>>
		{
			public DictionaryDmgNetProperty(string key, ZNetView zNetView, Dictionary<DamageType, float> defaultValue)
				: base(key, zNetView, defaultValue)
			{
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		[Serializable]
		public class ZoneData
		{
			public int ZoneId { get; set; }

			public float MinX { get; set; }

			public float MaxX { get; set; }

			public float MinZ { get; set; }

			public float MaxZ { get; set; }

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

			public int TotalKills { get; set; }

			public double LastDecayTimestamp { get; set; }

			public float CenterX => (MinX + MaxX) / 2f;

			public float CenterZ => (MinZ + MaxZ) / 2f;

			public bool ContainsPosition(Vector3 pos)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				if (pos.x >= MinX && pos.x < MaxX && pos.z >= MinZ)
				{
					return pos.z < MaxZ;
				}
				return false;
			}

			internal float GetLevelBonus()
			{
				if (ZoneLevel <= 1)
				{
					return 1f;
				}
				return (float)(ZoneLevel - 1) * ValConfig.ZoneLevelBonusPerLevel.Value;
			}
		}

		public class ZoneSystemSaveData
		{
			public List<ZoneData> Zones { get; set; } = new List<ZoneData>();

			public string WorldName { get; set; }
		}

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

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

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

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

			public override List<SerializableVector3> Get()
			{
				byte[] byteArray = zNetView.GetZDO().GetByteArray(base.Key, (byte[])null);
				if (byteArray == null)
				{
					return null;
				}
				List<SerializableVector3> list = new List<SerializableVector3>();
				int num = byteArray.Length / 12;
				for (int i = 0; i < num; i++)
				{
					list.Add(new SerializableVector3(BitConverter.ToSingle(byteArray, i * 12), BitConverter.ToSingle(byteArray, i * 12 + 4), BitConverter.ToSingle(byteArray, i * 12 + 8)));
				}
				return list;
			}

			protected override void SetValue(List<SerializableVector3> value)
			{
				byte[] array = new byte[value.Count * 12];
				for (int i = 0; i < value.Count; i++)
				{
					BitConverter.GetBytes(value[i].x).CopyTo(array, i * 12);
					BitConverter.GetBytes(value[i].y).CopyTo(array, i * 12 + 4);
					BitConverter.GetBytes(value[i].z).CopyTo(array, i * 12 + 8);
				}
				zNetView.GetZDO().Set(base.Key, array);
			}
		}

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

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

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

		public static IDeserializer yamlDeserializer = new DeserializerBuilder().WithCaseInsensitivePropertyMatching().Build();

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

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

		public static BinaryFormatter binFormatter = new BinaryFormatter();

		public static readonly string SLS_NAME = "SLS_NAME";

		public static readonly string SLS_DAMAGE_MODIFIER = "SLS_DMOD";

		public static readonly string SLS_DAMAGE_BONUSES = "SLS_DBON";

		public static readonly string SLS_SPAWN_MULT = "SLS_MULT";

		public static readonly string SLS_MODIFIERS = "SLS_MODS";

		public static readonly string SLS_MODSV2 = "SLS_MODV2";

		public static readonly string SLS_CHARNAME = "SLS_CHARNAME";

		public static readonly string SLS_TREE = "SLE_Tree";

		public static readonly string SLS_FISH = "SLE_Fish";

		public static readonly string SLS_BIRD = "SLE_Bird";

		public static readonly string SLS_INFERTILE = "SLS_Infertile";

		public static readonly string SLS_SOULEATER = "SLS_SoulEater";

		public static readonly string SLS_EVOLVE = "SLS_Evolve";

		public static readonly string SLS_SIZE = "SLS_SIZE";

		public static readonly string SLS_NEMESIS_SCORE = "SLS_NEM_SCORE";

		public static readonly string SLS_NEMESIS_SCOREDATA = "SLS_NEM_SCOREDATA";

		public static readonly string SLS_RAIDS_ACTIVE = "SLS_RAIDS_ACTIVE";

		public static readonly string SLS_CUSTOM_LOOT = "SLS_CUSTOM_LOOT";

		public static readonly string SLS_NEMESIS_BOSS = "SLS_NEM_BOSS";

		public static readonly string SLS_NEMESIS_PIN = "SLS_NEM_PIN";

		public static readonly string SLS_MOD_CAP = "EffectCap";

		public static List<CreatureBaseAttribute> CreatureBaseAttributes = new List<CreatureBaseAttribute>
		{
			CreatureBaseAttribute.BaseHealth,
			CreatureBaseAttribute.BaseDamage,
			CreatureBaseAttribute.Speed,
			CreatureBaseAttribute.AttackSpeed,
			CreatureBaseAttribute.Size
		};

		public static List<CreaturePerLevelAttribute> CreaturePerLevelAttributes = new List<CreaturePerLevelAttribute>
		{
			CreaturePerLevelAttribute.HealthPerLevel,
			CreaturePerLevelAttribute.DamagePerLevel,
			CreaturePerLevelAttribute.SpeedPerLevel,
			CreaturePerLevelAttribute.SizePerLevel
		};
	}
	internal static class DocumentationUpdater
	{
		public static void UpdateDocumentation()
		{
			string text = ToMarkdown(typeof(DataObjects.CreatureLevelSettings));
			Logger.LogInfo("Generated documentation:\n" + text);
		}

		public static string ToMarkdown(Type root)
		{
			StringBuilder stringBuilder = new StringBuilder();
			HashSet<Type> hashSet = new HashSet<Type>();
			Queue<Type> queue = new Queue<Type>();
			queue.Enqueue(root);
			while (queue.Count > 0)
			{
				Type type = queue.Dequeue();
				if (!hashSet.Add(type))
				{
					continue;
				}
				string item = ReadDocs(type).description;
				stringBuilder.AppendLine("## `" + type.Name + "`").AppendLine();
				if (!string.IsNullOrEmpty(item))
				{
					stringBuilder.AppendLine(item).AppendLine();
				}
				stringBuilder.AppendLine("| Property | Type | Default | Description |");
				stringBuilder.AppendLine("|---|---|---|---|");
				PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
				foreach (PropertyInfo propertyInfo in properties)
				{
					var (text, value) = ReadDocs(propertyInfo);
					stringBuilder.AppendLine("| `" + propertyInfo.Name + "` | `" + FriendlyTypeName(propertyInfo.PropertyType) + "` | " + FormatDefault(value) + " | " + text + " |");
					foreach (Type item2 in NestedUserTypes(propertyInfo.PropertyType))
					{
						queue.Enqueue(item2);
					}
				}
				stringBuilder.AppendLine();
			}
			return stringBuilder.ToString();
		}

		private static (string description, object defaultValue) ReadDocs(MemberInfo member)
		{
			string item = member.GetCustomAttribute<DescriptionAttribute>()?.Description ?? "";
			object item2 = member.GetCustomAttribute<DefaultValueAttribute>()?.Value;
			return (description: item, defaultValue: item2);
		}

		private static string FriendlyTypeName(Type t)
		{
			if (t == typeof(string))
			{
				return "string";
			}
			if (t == typeof(bool))
			{
				return "bool";
			}
			if (t == typeof(int))
			{
				return "int";
			}
			if (t == typeof(float))
			{
				return "float";
			}
			if (t == typeof(double))
			{
				return "double";
			}
			if (t == typeof(object))
			{
				return "object";
			}
			Type underlyingType = Nullable.GetUnderlyingType(t);
			if (underlyingType != null)
			{
				return FriendlyTypeName(underlyingType) + "?";
			}
			if (t.IsArray)
			{
				return FriendlyTypeName(t.GetElementType()) + "[]";
			}
			if (t.IsGenericType)
			{
				string text = t.Name.Substring(0, t.Name.IndexOf('`'));
				string text2 = string.Join(", ", t.GetGenericArguments().Select(FriendlyTypeName));
				return text + "<" + text2 + ">";
			}
			return t.Name;
		}

		private static string FormatDefault(object value)
		{
			if (value == null)
			{
				return "—";
			}
			if (value is bool)
			{
				if (!(bool)value)
				{
					return "`false`";
				}
				return "`true`";
			}
			if (value is string text)
			{
				if (text.Length != 0)
				{
					return "`\"" + text + "\"`";
				}
				return "`\"\"`";
			}
			if (value is float num)
			{
				return "`" + num.ToString(CultureInfo.InvariantCulture) + "f`";
			}
			if (value is double num2)
			{
				return "`" + num2.ToString(CultureInfo.InvariantCulture) + "`";
			}
			if (value is Enum obj)
			{
				return $"`{obj.GetType().Name}.{obj}`";
			}
			if (value is IFormattable formattable)
			{
				return "`" + formattable.ToString(null, CultureInfo.InvariantCulture) + "`";
			}
			return $"`{value}`";
		}

		private static IEnumerable<Type> NestedUserTypes(Type t)
		{
			Type underlyingType = Nullable.GetUnderlyingType(t);
			if (underlyingType != null)
			{
				t = underlyingType;
			}
			if (t.IsArray)
			{
				foreach (Type item in NestedUserTypes(t.GetElementType()))
				{
					yield return item;
				}
			}
			else if (t.IsGenericType)
			{
				Type[] genericArguments = t.GetGenericArguments();
				foreach (Type t2 in genericArguments)
				{
					foreach (Type item2 in NestedUserTypes(t2))
					{
						yield return item2;
					}
				}
			}
			else if (IsUserType(t))
			{
				yield return t;
			}
		}

		private static bool IsUserType(Type t)
		{
			if (t.Assembly == Assembly.GetExecutingAssembly() && !t.IsEnum && !t.IsPrimitive && t != typeof(string))
			{
				return t != typeof(decimal);
			}
			return false;
		}
	}
	internal static class LocalizationLoader
	{
		private static CustomLocalization Localization;

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

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

		private static string ReadEmbeddedResourceFile(string filename)
		{
			using Stream stream = typeof(StarLevelSystem).Assembly.GetManifestResourceStream(filename);
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}
	}
	internal static class RandomSelect
	{
		public static string RandomSelectFromWeightedListWithExclusions(List<DataObjects.ProbabilityEntry> listOfWeights, List<string> exclude)
		{
			List<DataObjects.ProbabilityEntry> list = listOfWeights.Where((DataObjects.ProbabilityEntry x) => !exclude.Contains(x.Name)).ToList();
			float num = list.Select((DataObjects.ProbabilityEntry x) => x.SelectionWeight).Sum();
			if (num == 0f)
			{
				return CreatureModifiers.NoMods;
			}
			float num2 = Random.Range(0f, num);
			float num3 = 0f;
			foreach (DataObjects.ProbabilityEntry listOfWeight in listOfWeights)
			{
				num3 += listOfWeight.SelectionWeight;
				if (num3 >= num2)
				{
					return listOfWeight.Name;
				}
			}
			return list.ToArray()[Random.Range(0, listOfWeights.Count - 1)].Name;
		}
	}
	public static class SLSExtensions
	{
		public static List<T> ShuffleList<T>(this List<T> inputList)
		{
			int i = 0;
			int count = inputList.Count;
			int num = 0;
			T val = default(T);
			List<T> list = new List<T>();
			list.AddRange(inputList);
			for (; i < count; i++)
			{
				num = Random.Range(i, list.Count);
				val = list[i];
				list[i] = list[num];
				list[num] = val;
			}
			return list;
		}

		public static bool CompareListContents<T>(this List<T> listA, List<T> listB)
		{
			if (listA == null && listB == null)
			{
				return true;
			}
			if (listA == null || listB == null)
			{
				return false;
			}
			if (listA.Count != listB.Count)
			{
				return false;
			}
			List<T> source = listA.Except(listB).ToList();
			List<T> source2 = listB.Except(listA).ToList();
			if (!source.Any())
			{
				return !source2.Any();
			}
			return false;
		}

		public static int GetLabelValue(Label label)
		{
			return (int)typeof(Label).GetMethod("GetLabelValue", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(label, null);
		}

		public static CodeMatcher CreateLabelOffset(this CodeMatcher matcher, out Label label, int offset = 0)
		{
			return matcher.CreateLabelAt(matcher.Pos + offset, ref label);
		}

		public static CodeMatcher ExtractLabel(this CodeMatcher matcher, out Label elabel, int searchrange = 1, int labelToSelect = 0)
		{
			elabel = default(Label);
			List<CodeInstruction> list = matcher.Instructions();
			int num = Math.Min(list.Count, matcher.Pos + 1 + searchrange);
			bool flag = false;
			List<Label> list2 = new List<Label>();
			for (int i = matcher.Pos + 1; i < num; i++)
			{
				CodeInstruction val = list[i];
				List<Label> labels = val.labels;
				if (labels == null || labels.Count <= 0)
				{
					continue;
				}
				Logger.LogDebug($"found labels: {val.labels.Count}");
				int num2 = 0;
				{
					foreach (Label label in val.labels)
					{
						list2.Add(label);
						if (list2.Count == labelToSelect + 1)
						{
							Logger.LogDebug($"Selected Label {GetLabelValue(label)}");
							val.labels.RemoveAt(num2);
						}
						num2++;
					}
					return matcher;
				}
			}
			if (!flag)
			{
				throw new InvalidOperationException($"No label found within {searchrange} instructions ahead of position {matcher.Pos}.");
			}
			return matcher;
		}

		public static CodeMatcher ExtractLabelOnNextInstructionOfType(this CodeMatcher matcher, CodeInstruction op, out Label label)
		{
			List<CodeInstruction> range = matcher.Instructions().GetRange(matcher.Pos - 1, matcher.Instructions().Count - matcher.Pos - 1);
			bool flag = false;
			label = default(Label);
			foreach (CodeInstruction item in range)
			{
				if (item == op)
				{
					flag = true;
					if (item.labels.Count > 0)
					{
						label = item.labels[0];
					}
					else
					{
						Logger.LogWarning($"No Labels found on the selected CodeInstruction {item.opcode}");
					}
				}
			}
			if (!flag)
			{
				throw new InvalidOperationException("Did not match an opcode.");
			}
			return matcher;
		}

		public static CodeMatcher SelectLabelInRange(this CodeMatcher matcher, int key, out Label label, int keyindex = 0)
		{
			List<CodeInstruction> list = matcher.Instructions();
			int num = 0;
			label = default(Label);
			Dictionary<int, List<Label>> dictionary = new Dictionary<int, List<Label>>();
			foreach (CodeInstruction item in list)
			{
				if (item.labels.Count > 0)
				{
					dictionary.Add(num, item.labels);
					Logger.LogDebug($"Found Label at index {num} on {item.opcode} label-target: {item.labels[0]}");
				}
				num++;
			}
			if (dictionary.ContainsKey(key))
			{
				if (dictionary[key].Count > 0)
				{
					label = dictionary[key][keyindex];
				}
				else
				{
					label = dictionary[key][0];
				}
			}
			else
			{
				Logger.LogWarning($"Keyed label was not found with key {key}");
			}
			Logger.LogDebug(string.Format("Label indexes {0} current position: {1}", string.Join(",", dictionary.Keys), matcher.Pos));
			return matcher;
		}

		public static CodeMatcher ExtractFirstLabel(this CodeMatcher matcher, out Label label)
		{
			label = matcher.Labels.First();
			matcher.Labels.Clear();
			return matcher;
		}

		public static void Times(this int count, Action action)
		{
			for (int i = 0; i < count; i++)
			{
				action();
			}
		}

		public static KeyValuePair<string, List<string>> RandomEntry(Dictionary<string, List<string>> dict, List<string> removedKeys = null)
		{
			List<string> list = dict.Keys.ToList();
			if (removedKeys != null)
			{
				list = list.Where((string k) => !removedKeys.Contains(k)).ToList();
			}
			if (list.Count == 0)
			{
				return new KeyValuePair<string, List<string>>(CreatureModifiers.NoMods, null);
			}
			string key = list[Random.Range(0, list.Count - 1)];
			return new KeyValuePair<string, List<string>>(key, dict[key]);
		}

		public static List<Character> GetCharactersInRange(Vector3 position, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(position, range);
			List<Character> list = new List<Character>();
			Collider[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				Character componentInChildren = ((Component)array2[i]).GetComponentInChildren<Character>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					list.Add(componentInChildren);
				}
			}
			return list;
		}

		public static List<Player> GetPlayersInRange(Vector3 position, float range)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(position, range);
			List<Player> list = new List<Player>();
			Collider[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				Player componentInChildren = ((Component)array2[i]).GetComponentInChildren<Player>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					list.Add(componentInChildren);
				}
			}
			return list;
		}

		public static List<ZNetPeer> ServerGetPeersInArea(Vector3 pos, float radius)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			List<ZNetPeer> list = new List<ZNetPeer>();
			if (!Object.op_Implicit((Object)(object)ZNet.instance) || !ZNet.instance.IsServer())
			{
				return list;
			}
			float num = radius * radius;
			foreach (ZNetPeer peer in ZNet.instance.m_peers)
			{
				if (peer.IsReady() && !(peer.m_characterID == ZDOID.None) && Utils.DistanceSqr(peer.m_refPos, pos) <= num)
				{
					list.Add(peer);
				}
			}
			return list;
		}

		internal static float GetTotalDamageOptions(this DamageTypes hitdmg, bool include_poison = false, bool include_spirit = false, bool include_pickaxe_and_chop = false, float modElement = 1f, float modPhysical = 1f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			float num = (hitdmg.m_damage + hitdmg.m_blunt + hitdmg.m_slash + hitdmg.m_pierce) * modPhysical;
			float num2 = (hitdmg.m_fire + hitdmg.m_frost + hitdmg.m_lightning) * modElement;
			float num3 = num + num2;
			if (include_poison)
			{
				num3 += hitdmg.m_poison * modElement;
			}
			if (include_spirit)
			{
				num3 += hitdmg.m_spirit * modElement;
			}
			if (include_pickaxe_and_chop)
			{
				num3 += hitdmg.m_pickaxe + hitdmg.m_chop;
			}
			return num3;
		}

		public static float EstimateCharacterDamage(Character chara, DataObjects.DamageEstimateType det)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)chara == (Object)null || chara.IsPlayer())
			{
				return 0f;
			}
			Humanoid val = (Humanoid)(object)((chara is Humanoid) ? chara : null);
			if ((Object)(object)val == (Object)null)
			{
				return 0f;
			}
			float num = 0f;
			float modElement = 0.5f;
			switch (det)
			{
			case DataObjects.DamageEstimateType.Highest:
			{
				GameObject[] defaultItems = val.m_defaultItems;
				for (int i = 0; i < defaultItems.Length; i++)
				{
					float totalDamageOptions2 = defaultItems[i].GetComponent<ItemDrop>().m_itemData.m_shared.m_damages.GetTotalDamageOptions(include_poison: true, include_spirit: true, include_pickaxe_and_chop: false, modElement);
					if (totalDamageOptions2 > num)
					{
						num = totalDamageOptions2;
					}
				}
				break;
			}
			case DataObjects.DamageEstimateType.Average:
			{
				float num2 = 0f;
				GameObject[] defaultItems = val.m_defaultItems;
				for (int i = 0; i < defaultItems.Length; i++)
				{
					float totalDamageOptions3 = defaultItems[i].GetComponent<ItemDrop>().m_itemData.m_shared.m_damages.GetTotalDamageOptions(include_poison: true, include_spirit: true, include_pickaxe_and_chop: false, modElement);
					num2 += totalDamageOptions3;
				}
				num = num2 / (float)val.m_defaultItems.Count();
				break;
			}
			case DataObjects.DamageEstimateType.Lowest:
			{
				GameObject[] defaultItems = val.m_defaultItems;
				for (int i = 0; i < defaultItems.Length; i++)
				{
					float totalDamageOptions = defaultItems[i].GetComponent<ItemDrop>().m_itemData.m_shared.m_damages.GetTotalDamageOptions(include_poison: true, include_spirit: true, include_pickaxe_and_chop: false, modElement);
					if (totalDamageOptions < num)
					{
						num = totalDamageOptions;
					}
				}
				break;
			}
			}
			if (num == 0f)
			{
				ItemData currentWeapon = val.GetCurrentWeapon();
				if (currentWeapon != null)
				{
					DamageTypes damage = currentWeapon.GetDamage();
					num = damage.m_fire + damage.m_frost + damage.m_lightning + damage.m_spirit / 2f + damage.m_poison / 6f + damage.m_blunt + damage.m_pierce + damage.m_slash;
				}
			}
			num = Mathf.Clamp(num, 0f, 500f);
			if (float.IsNaN(num))
			{
				num = 100f;
			}
			Logger.LogDebug($"Estimated {chara.m_name} damage as: {num}");
			return num;
		}

		public static SortedDictionary<int, float> MergeSortedDictionary(this SortedDictionary<int, float> primaryDict, SortedDictionary<int, float> otherDict, bool addative = true)
		{
			foreach (int key in otherDict.Keys)
			{
				if (primaryDict.ContainsKey(key))
				{
					if (addative)
					{
						primaryDict[key] += otherDict[key];
					}
					else
					{
						primaryDict[key] = otherDict[key];
					}
				}
				else
				{
					primaryDict.Add(key, otherDict[key]);
				}
			}
			return primaryDict;
		}

		public static DataObjects.BiomeSpecificSetting MutatingMergeBiomeConfigs(DataObjects.BiomeSpecificSetting prioritycfg, DataObjects.BiomeSpecificSetting othercfg)
		{
			DataObjects.BiomeSpecificSetting biomeSpecificSetting = new DataObjects.BiomeSpecificSetting
			{
				BiomeMaxLevelOverride = othercfg.BiomeMaxLevelOverride,
				BiomeMinLevelOverride = othercfg.BiomeMinLevelOverride,
				CreatureBaseValueModifiers = othercfg.CreatureBaseValueModifiers,
				CreaturePerLevelValueModifiers = othercfg.CreaturePerLevelValueModifiers,
				CreatureSpawnsDisabled = othercfg.CreatureSpawnsDisabled,
				CustomCreatureLevelUpChance = othercfg.CustomCreatureLevelUpChance,
				DamageRecievedModifiers = othercfg.DamageRecievedModifiers,
				DistanceScaleModifier = othercfg.DistanceScaleModifier,
				SpawnRateModifier = othercfg.SpawnRateModifier
			};
			if (prioritycfg.CustomCreatureLevelUpChance != null)
			{
				biomeSpecificSetting.CustomCreatureLevelUpChance = prioritycfg.CustomCreatureLevelUpChance;
			}
			biomeSpecificSetting.BiomeMaxLevelOverride = prioritycfg.BiomeMaxLevelOverride;
			biomeSpecificSetting.DistanceScaleModifier = prioritycfg.DistanceScaleModifier;
			if (prioritycfg.SpawnRateModifier != 1f)
			{
				biomeSpecificSetting.SpawnRateModifier = prioritycfg.SpawnRateModifier;
			}
			if (biomeSpecificSetting.CreatureBaseValueModifiers != null && prioritycfg.CreatureBaseValueModifiers != null)
			{
				biomeSpecificSetting.CreatureBaseValueModifiers.ToList().ForEach(delegate(KeyValuePair<DataObjects.CreatureBaseAttribute, float> x)
				{
					prioritycfg.CreatureBaseValueModifiers[x.Key] = x.Value;
				});
			}
			else if (prioritycfg.CreatureBaseValueModifiers != null)
			{
				biomeSpecificSetting.CreatureBaseValueModifiers = prioritycfg.CreatureBaseValueModifiers;
			}
			if (biomeSpecificSetting.CreaturePerLevelValueModifiers != null && prioritycfg.CreaturePerLevelValueModifiers != null)
			{
				biomeSpecificSetting.CreaturePerLevelValueModifiers.ToList().ForEach(delegate(KeyValuePair<DataObjects.CreaturePerLevelAttribute, float> x)
				{
					prioritycfg.CreaturePerLevelValueModifiers[x.Key] = x.Value;
				});
			}
			else if (prioritycfg.CreaturePerLevelValueModifiers != null)
			{
				biomeSpecificSetting.CreaturePerLevelValueModifiers = prioritycfg.CreaturePerLevelValueModifiers;
			}
			if (biomeSpecificSetting.DamageRecievedModifiers != null && prioritycfg.DamageRecievedModifiers != null)
			{
				biomeSpecificSetting.DamageRecievedModifiers.ToList().ForEach(delegate(KeyValuePair<DataObjects.DamageType, float> x)
				{
					prioritycfg.DamageRecievedModifiers[x.Key] = x.Value;
				});
			}
			else if (prioritycfg.DamageRecievedModifiers != null)
			{
				biomeSpecificSetting.DamageRecievedModifiers = prioritycfg.DamageRecievedModifiers;
			}
			if (prioritycfg.CreatureSpawnsDisabled != null)
			{
				biomeSpecificSetting.CreatureSpawnsDisabled = prioritycfg.CreatureSpawnsDisabled;
				if (othercfg.CreatureSpawnsDisabled != null)
				{
					biomeSpecificSetting.CreatureSpawnsDisabled = prioritycfg.CreatureSpawnsDisabled.Union(othercfg.CreatureSpawnsDisabled).ToList();
				}
			}
			if (prioritycfg.NightSettings != null || othercfg.NightSettings != null)
			{
				DataObjects.BiomeNightSettings nightSettings = prioritycfg.NightSettings;
				DataObjects.BiomeNightSettings nightSettings2 = othercfg.NightSettings;
				DataObjects.BiomeNightSettings biomeNightSettings = new DataObjects.BiomeNightSettings();
				if (nightSettings != null)
				{
					biomeNightSettings.SpawnRateModifier = nightSettings.SpawnRateModifier;
					biomeNightSettings.NightLevelUpChanceScaler = nightSettings.NightLevelUpChanceScaler;
				}
				else
				{
					biomeNightSettings.SpawnRateModifier = nightSettings2.SpawnRateModifier;
					biomeNightSettings.NightLevelUpChanceScaler = nightSettings2.NightLevelUpChanceScaler;
				}
				List<string> list = new List<string>();
				if (nightSettings2 != null && nightSettings2.CreatureSpawnsDisabled != null)
				{
					list = list.Union(nightSettings2.CreatureSpawnsDisabled).ToList();
				}
				if (nightSettings != null && nightSettings.CreatureSpawnsDisabled != null)
				{
					list = list.Union(nightSettings.CreatureSpawnsDisabled).ToList();
				}
				biomeNightSettings.CreatureSpawnsDisabled = list;
				biomeSpecificSetting.NightSettings = biomeNightSettings;
			}
			else
			{
				biomeSpecificSetting.NightSettings = null;
			}
			return biomeSpecificSetting;
		}

		public static ZNetPeer GetPeerByPlatformID(string platformAndID)
		{
			string text = platformAndID;
			if (platformAndID.Contains("Steam"))
			{
				text = platformAndID.Split(new char[1] { '_' })[1];
			}
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				if (peer.IsReady() && peer.m_socket.GetHostName() == text)
				{
					return peer;
				}
			}
			return null;
		}

		public static PlatformUserID GetPlatformUserID(long peerID)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			ZNetPeer peer = ZNet.instance.GetPeer(peerID);
			if (peer == null || !peer.IsReady())
			{
				return PlatformUserID.None;
			}
			foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
			{
				if (player.m_characterID == peer.m_characterID)
				{
					return player.m_userInfo.m_id;
				}
			}
			return PlatformUserID.None;
		}

		public static string GetLocalUserPlatformAndID()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((object)((IUser)PlatformManager.DistributionPlatform.LocalUser).PlatformUserID/*cast due to .constrained prefix*/).ToString();
		}

		public unsafe static bool PlatformAndIDIsPlayerOnline(string PlatformAndID)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
			{
				Platform platform = player.m_userInfo.m_id.m_platform;
				string text = ((object)(*(Platform*)(&platform))/*cast due to .constrained prefix*/).ToString() + "_" + player.m_userInfo.m_id.m_userID.ToString();
				Logger.LogDebug("Checking " + text + " == " + PlatformAndID);
				if (text == PlatformAndID)
				{
					return true;
				}
			}
			return false;
		}

		public static Vector3 GetPlayerPosition(ZDOID characterID)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (((ZDOID)(ref characterID)).IsNone() || ZDOMan.instance == null)
			{
				return Vector3.zero;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(characterID);
			if (zDO == null)
			{
				return Vector3.zero;
			}
			return zDO.GetPosition();
		}

		public static List<string> GetPrivateKeysSanitize(this Player player)
		{
			return (from x in player.GetUniqueKeys()
				where !string.IsNullOrEmpty(x)
				select x).ToList();
		}

		public static ZNetPeer GetNearestReadyPeer(Vector3 pos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return null;
			}
			return (from peer in ZNet.instance.GetPeers()
				where peer != null && peer.IsReady() && peer.m_characterID != ZDOID.None
				orderby Utils.DistanceXZ(peer.m_refPos, pos)
				select peer).FirstOrDefault();
		}
	}
	internal static class TerminalCommands
	{
		internal class RebuildZones : ConsoleCommand
		{
			public override string Name => "SLS-rebuild-zones";

			public override string Help => "Clears existing zones and regenerates the zone map from the world, then redraws the minimap overlay. Resets zone kill counts and levels.";

			public override bool IsCheat => true;

			public override void Run(string[] args)
			{
				ZoneScaleSystem.RebuildZones();
			}
		}

		internal class KillAllCreaturesNearby : ConsoleCommand
		{
			public override string Name => "SLS-killall";

			public override string Help => "Format: [optional: range] eg: sls-killall 500";

			public override void Run(string[] args)
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				float range = 500f;
				if (args.Length > 1)
				{
					Logger.LogInfo("Optional argument of range is the only supported argument. Ensure your command follows the format: sls-killall 500");
				}
				if (args.Length != 0)
				{
					try
					{
						range = float.Parse(args[0]);
					}
					catch (Exception ex)
					{
						Logger.LogInfo("Optional argument of range must be a valid number. Ensure your command follows the format: sls-killall 500");
						Logger.LogWarning(ex.Message);
					}
				}
				foreach (Character item in SLSExtensions.GetCharactersInRange(((Component)Player.m_localPlayer).transform.position, range))
				{
					if (!item.IsPlayer() && !item.IsTamed())
					{
						CharacterDrop component = ((Component)item).gameObject.GetComponent<CharacterDrop>();
						if ((Object)(object)component != (Object)null)
						{
							Object.Destroy((Object)(object)component);
						}
						if ((Object)(object)item != (Object)null)
						{
							Object.Destroy((Object)(object)((Component)item).gameObject);
						}
					}
				}
			}
		}

		internal class SetNemesisScore : ConsoleCommand
		{
			public override string Name => "SLS-SetNem-Score";

			public override string Help => "Format: [required: value] eg: sls-setnem-score 500";

			public override void Run(string[] args)
			{
				float.TryParse(args[0], out var result);
				float num = Mathf.Clamp(result, NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.MinScore, NemesisSystemData.SLE_Nemesis_Settings.ScoreSystem.MaxScore);
				NemesisScoreSystem.SetScore(Player.m_localPlayer, num);
				NemesisSystem.CachedPlayerScore = num;
				Logger.LogInfo($"Set Local player Nemesis score to {num}");
			}
		}

		internal class SpawnNemesisRemote : ConsoleCommand
		{
			public override string Name => "SLS-spawn-nemesis-remote";

			public override string Help => "Format: [optional: biome] Force-scouts and places one remote Nemesis boss. On a dedicated server, admins can run it from a connected client.";

			public override void Run(string[] args)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: 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_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ZNet.instance == (Object)null)
				{
					Logger.LogInfo("You must be in a world to spawn a remote Nemesis boss.");
					return;
				}
				if (!ZNet.instance.IsServer() && !SynchronizationManager.Instance.PlayerIsAdmin)
				{
					Logger.LogInfo("Only server admins can force-spawn a remote Nemesis boss.");
					return;
				}
				Biome val = (Biome)1;
				if (args.Length >= 1 && Enum.TryParse<Biome>(args[0], ignoreCase: true, out Biome result) && (int)result != 0)
				{
					val = result;
				}
				else if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					val = Heightmap.FindBiome(((Component)Player.m_localPlayer).transform.position);
				}
				if (ZNet.instance.IsServer())
				{
					Logger.LogInfo($"Force-spawning a remote Nemesis boss for biome {val}...");
				}
				else
				{
					Logger.LogInfo($"Requesting the server force-spawn a remote Nemesis boss for biome {val}...");
				}
				if (!NemesisRemoteSpawnControl.RequestForceSpawn(val))
				{
					Logger.LogInfo("Unable to request a remote Nemesis spawn (no server connection or remote spawning is unavailable).");
				}
			}
		}

		internal class GiveCreatureModifier : ConsoleCommand
		{
			public override string Name => "SLS-give-modifier";

			public override string Help => "Format: [boss/major/minor] [modifier-name] Gives nearby creatures the specified modifier";

			public override void Run(string[] args)
			{
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				if (args.Length < 2)
				{
					Logger.LogInfo("Two arguments required, modifier type and modifier name. Eg: Major FireNova");
				}
				if (!Enum.TryParse<DataObjects.ModifierType>(args[0], ignoreCase: true, out var result))
				{
					Logger.LogInfo("Modifier type must be one of " + string.Join(",", Enum.GetValues(typeof(DataObjects.ModifierType))));
				}
				if (!Enum.TryParse<CreatureModifiersData.ModifierNames>(args[1], ignoreCase: true, out var result2))
				{
					Logger.LogInfo("Modifier Name must be one of " + string.Join(",", Enum.GetValues(typeof(CreatureModifiersData.ModifierNames))));
				}
				DataObjects.CreatureModConfig config = CreatureModifiersData.GetConfig(result2.ToString(), result);
				if (config.PerlevelPower == float.NaN || (config.PerlevelPower == 0f && config.BasePower == float.NaN) || config.BasePower == 0f)
				{
					Logger.LogInfo(string.Format("{0} did not contain a definition for {1}. Types availabe in {2}: {3}", result, result2, result, string.Join(",", CreatureModifiersData.GetModifiersOfType(result).Keys)));
				}
				List<Character> charactersInRange = SLSExtensions.GetCharactersInRange(((Component)Player.m_localPlayer).transform.position, 5f);
				Logger.LogInfo($"Adding {result} {result2} to {charactersInRange.Count}");
				foreach (Character item in charactersInRange)
				{
					if (!item.IsPlayer())
					{
						CreatureModifiers.AddCreatureModifier(item, result, result2.ToString());
					}
				}
			}
		}

		internal class ResetZOIDModifiers : ConsoleCommand
		{
			public override string Name => "SLS-reset-player-modifiers";

			public override string Help => "Resets all of the modified damage, movementspeed, scale, health values that are assigned to the player.";

			public override void Run(string[] args)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				ZDOID zDOID = ((Character)Player.m_localPlayer).GetZDOID();
				uint iD = ((ZDOID)(ref zDOID)).ID;
				((Character)Player.m_localPlayer).m_nview.GetZDO().Set(DataObjects.SLS_DAMAGE_MODIFIER, 1f);
				DataObjects.DictionaryDmgNetProperty dictionaryDmgNetProperty = new DataObjects.DictionaryDmgNetProperty(DataObjects.SLS_DAMAGE_BONUSES, ((Character)Player.m_localPlayer).m_nview, new Dictionary<DataObjects.DamageType, float>());
				Dictionary<DataObjects.DamageType, float> value = new Dictionary<DataObjects.DamageType, float>
				{
					{
						DataObjects.DamageType.Blunt,
						0f
					},
					{
						DataObjects.DamageType.Slash,
						0f
					},
					{
						DataObjects.DamageType.Pierce,
						0f
					},
					{
						DataObjects.DamageType.Frost,
						0f
					},
					{
						DataObjects.DamageType.Lightning,
						0f
					},
					{
						DataObjects.DamageType.Poison,
						0f
					},
					{
						DataObjects.DamageType.Spirit,
						0f
					},
					{
						DataObjects.DamageType.Fire,
						0f
					},
					{
						DataObjects.DamageType.Chop,
						0f
					},
					{
						DataObjects.DamageType.Pickaxe,
						0f
					}
				};
				dictionaryDmgNetProperty.Set(value);
				Logger.LogInfo($"Reset Player {iD}");
			}
		}

		internal class DumpLootTablesCommand : ConsoleCommand
		{
			public override string Name => "SLS-Dump-LootTables";

			public override string Help => "Writes all creature loot-tables to a debug file.";

			public override bool IsCheat => true;

			public override void Run(string[] args)
			{
				//IL_0295: Unknown result type (might be due to invalid IL or missing references)
				//IL_029a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_0300: Unknown result type (might be due to invalid IL or missing references)
				//IL_0316: Unknown result type (might be due to invalid IL or missing references)
				//IL_0436: Unknown result type (might be due to invalid IL or missing references)
				//IL_043b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0449: Unknown result type (might be due to invalid IL or missing references)
				//IL_045b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0468: Unknown result type (might be due to invalid IL or missing references)
				//IL_048e: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_05f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_061d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0630: Unknown result type (might be due to invalid IL or missing references)
				//IL_0646: Unknown result type (might be due to invalid IL or missing references)
				//IL_0766: Unknown result type (might be due to invalid IL or missing references)
				//IL_076b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0779: Unknown result type (might be due to invalid IL or missing references)
				//IL_0786: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_07bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_08f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_08fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0908: Unknown result type (might be due to invalid IL or missing references)
				//IL_0915: Unknown result type (might be due to invalid IL or missing references)
				//IL_093b: Unknown result type (might be due to invalid IL or missing references)
				//IL_094e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0964: Unknown result type (might be due to invalid IL or missing references)
				string path = Path.Combine(Paths.ConfigPath, "StarLevelSystem", "LootTablesDump.yaml");
				Dictionary<string, List<DataObjects.ExtendedCharacterDrop>> dictionary = new Dictionary<string, List<DataObjects.ExtendedCharacterDrop>>();
				foreach (CharacterDrop item in (from cdrop in Resources.FindObjectsOfTypeAll<CharacterDrop>()
					where !((Object)cdrop).name.EndsWith("(Clone)")
					select cdrop).ToList())
				{
					Logger.LogDebug("Checking " + ((Object)item).name + " for loot tables");
					string name = ((Object)item).name;
					if (dictionary.ContainsKey(name))
					{
						continue;
					}
					Logger.LogDebug("checking " + name);
					List<DataObjects.ExtendedCharacterDrop> list = new List<DataObjects.ExtendedCharacterDrop>();
					Logger.LogDebug($"drops {item.m_drops.Count}");
					foreach (Drop drop in item.m_drops)
					{
						DataObjects.ExtendedCharacterDrop extendedCharacterDrop = new DataObjects.ExtendedCharacterDrop
						{
							Drop = new DataObjects.Drop
							{
								Min = drop.m_amountMin,
								Max = drop.m_amountMax,
								Chance = drop.m_chance,
								OnePerPlayer = drop.m_onePerPlayer,
								LevelMultiplier = drop.m_levelMultiplier,
								DontScale = drop.m_dontScale
							}
						};
						if ((Object)(object)drop.m_prefab != (Object)null)
						{
							extendedCharacterDrop.Drop.Prefab = ((Object)drop.m_prefab).name;
						}
						list.Add(extendedCharacterDrop);
					}
					dictionary.Add(name, list);
					Logger.LogDebug("Adding " + name + " loot-table");
				}
				Dictionary<string, List<DataObjects.ExtendedObjectDrop>> dictionary2 = new Dictionary<string, List<DataObjects.ExtendedObjectDrop>>();
				Logger.LogDebug("Checking TreeLogs for loot tables");
				foreach (TreeLog item2 in (from cdrop in Resources.FindObjectsOfTypeAll<TreeLog>()
					where !((Object)cdrop).name.EndsWith("(Clone)")
					select cdrop).ToList())
				{
					string prefabName = Utils.GetPrefabName(((Component)item2).gameObject);
					Logger.LogDebug("Checking " + prefabName + " for loot tables");
					if (dictionary2.ContainsKey(prefabName))
					{
						continue;
					}
					List<DataObjects.ExtendedObjectDrop> list2 = new List<DataObjects.ExtendedObjectDrop>();
					Logger.LogDebug($"drops {item2.m_dropWhenDestroyed.m_drops.Count}");
					foreach (DropData drop2 in item2.m_dropWhenDestroyed.m_drops)
					{
						DataObjects.ExtendedObjectDrop extendedObjectDrop = new DataObjects.ExtendedObjectDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = ((Object)drop2.m_item).name,
								Min = drop2.m_stackMin,
								Max = drop2.m_stackMax,
								Chance = item2.m_dropWhenDestroyed.m_dropChance,
								LevelMultiplier = false,
								DontScale = drop2.m_dontScale
							}
						};
						if ((Object)(object)drop2.m_item != (Object)null)
						{
							extendedObjectDrop.Drop.Prefab = ((Object)drop2.m_item).name;
						}
						list2.Add(extendedObjectDrop);
					}
					dictionary2.Add(prefabName, list2);
				}
				Logger.LogDebug("Checking Minerock5 for loot tables");
				foreach (MineRock5 item3 in (from cdrop in Resources.FindObjectsOfTypeAll<MineRock5>()
					where !((Object)cdrop).name.EndsWith("(Clone)")
					select cdrop).ToList())
				{
					string prefabName2 = Utils.GetPrefabName(((Component)item3).gameObject);
					Logger.LogDebug("Checking " + prefabName2 + " for loot tables");
					if (dictionary2.ContainsKey(prefabName2))
					{
						continue;
					}
					List<DataObjects.ExtendedObjectDrop> list3 = new List<DataObjects.ExtendedObjectDrop>();
					Logger.LogDebug($"drops {item3.m_dropItems.m_drops.Count}");
					foreach (DropData drop3 in item3.m_dropItems.m_drops)
					{
						DataObjects.ExtendedObjectDrop extendedObjectDrop2 = new DataObjects.ExtendedObjectDrop
						{
							Drop = new DataObjects.Drop
							{
								Prefab = ((Object)drop3.m_item).name,
								Min = drop3.m_stackMin,
								Max = drop3.m_stackMax,
								Chance = item3.m_dropItems.m_dropChance,
								LevelMultiplier = false,
								DontScale = drop3.m_dontScale
							}
						};
						if ((Object)(object)drop3.m_item != (Object)null)
						{
							extendedObjectDrop2.Drop.Prefab = ((Object)drop3.m_item).name;
						}
						list3.Add(extendedObjectDrop2);
					}
					dictionary2.Add(prefabName2, list3);
				}
				Logger.LogDebug("Checking Minerock for loot tables");
				foreach (MineRock item4 in (from cdrop in Resources.FindObjectsOfTypeAll<MineRock>()
					where !((Object)cdrop).name.EndsWith("(Clone)")
					select cdrop).ToList())
				{
					string prefabName3 = Utils.GetPrefabName(((Component)item4).gameObject);
					Logger.LogDebug("Checking " + prefabName3 + " for loot tables");
					if (dictionary2.ContainsKey(prefabName3))
					{
						continue;
					}
					List<DataObjects.ExtendedObjectDrop> list4 = new List<DataObjects.ExtendedObjectDrop>();
					Logger.LogDebug($"drops {item4.m_dropItems.m_drops.Count}");
					foreach (DropData drop4 in item4.m_dropItems.m_drops)
					{
						DataObjects.ExtendedObjectDrop extendedObjectDrop3 = new DataObjects.ExtendedObjectDrop
						{
							Drop = new DataObjects.Drop
							{
								Min = drop4.m_stackMin,
								Max = drop4.m_stackMax,
								Chance = item4.m_dropItems.m_dropChance,
								LevelMultiplier = false,
								DontScale = drop4.m_dontScale
							}
						};
						if ((Object)(object)drop4.m_item != (Object)null)
						{
							extendedObjectDrop3.Drop.Prefab = ((Object)drop4.m_item).name;
						}
						list4.Add(extendedObjectDrop3);
					}
					dictionary2.Add(prefabName3, list4);
				}
				Logger.LogDebug("Checking DropOnDestroyed for loot tables");
				foreach (DropOnDestroyed item5 in (from cdrop in Resources.FindObjectsOfTypeAll<DropOnDestroyed>()
					where !((Object)cdrop).name.EndsWith("(Clone)") && !((Object)cdrop).name.Contains(" ")
					select cdrop).ToList())
				{
					string prefabName4 = Utils.GetPrefabName(((Component)item5).gameObject);
					Logger.LogDebug("Checking " + prefabName4 + " for loot tables");
					if (dictionary2.ContainsKey(prefabName4))
					{
						continue;
					}
					List<DataObjects.ExtendedObjectDrop> list5 = new List<DataObjects.ExtendedObjectDrop>();
					Logger.LogDebug($"drops {item5.m_dropWhenDestroyed.m_drops.Count}");
					foreach (DropData drop5 in item5.m_dropWhenDestroyed.m_drops)
					{
						DataObjects.ExtendedObjectDrop extendedObjectDrop4 = new DataObjects.ExtendedObjectDrop
						{
							Drop = new DataObjects.Drop
							{
								Min = drop5.m_stackMin,
								Max = drop5.m_stackMax,
								Chance = item5.m_dropWhenDestroyed.m_dropChance,
								LevelMultiplier = false,
								DontScale = drop5.m_dontScale
							}
						};
						if ((Object)(object)drop5.m_item != (Object)null)
						{
							extendedObjectDrop4.Drop.Prefab = ((Object)drop5.m_item).name;
						}
						list5.Add(extendedObjectDrop4);
					}
					dictionary2.Add(prefabName4, list5);
				}
				Logger.LogDebug("Checking TreeBase for loot tables");
				foreach (TreeBase item6 in (from cdrop in Resources.FindObjectsOfTypeAll<TreeBase>()
					where !((Object)cdrop).name.EndsWith("(Clone)") && !((Object)cdrop).name.Contains(" ")
					select cdrop).ToList())
				{
					string prefabName5 = Utils.GetPrefabName(((Component)item6).gameObject);
					Logger.LogDebug("Checking " + prefabName5 + " for loot tables");
					if (dictionary2.ContainsKey(prefabName5))
					{
						continue;
					}
					List<DataObjects.ExtendedObjectDrop> list6 = new List<DataObjects.ExtendedObjectDrop>();
					Logger.LogDebug($"drops {item6.m_dropWhenDestroyed.m_drops.Count}");
					foreach (DropData drop6 in item6.m_dropWhenDestroyed.m_drops)
					{
						DataObjects.ExtendedObjectDrop extendedObjectDrop5 = new DataObjects.ExtendedObjectDrop
						{
							Drop = new DataObjects.Drop
							{
								Min = drop6.m_stackMin,
								Max = drop6.m_stackMax,
								Chance = item6.m_dropWhenDestroyed.m_dropChance,
								LevelMultiplier = false,
								DontScale = drop6.m_dontScale
							}
						};
						if ((Object)(object)drop6.m_item != (Object)null)
						{
							extendedObjectDrop5.Drop.Prefab = ((Object)drop6.m_item).name;
						}
						list6.Add(extendedObjectDrop5);
					}
					dictionary2.Add(prefabName5, list6);
				}
				Logger.LogDebug("Serializing data");
				DataObjects.LootSettings lootSettings = new DataObjects.LootSettings();
				lootSettings.CharacterSpecificLoot = dictionary;
				lootSettings.NonCharacterSpecificLoot = dictionary2;
				string value = DataObjects.yamlSerializer.Serialize((object)lootSettings);
				Logger.LogDebug("Writing file to disk");
				using StreamWriter streamWriter = new StreamWriter(path);
				streamWriter.WriteLine(value);
			}
		}

		internal static void AddCommands()
		{
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ResetZOIDModifiers());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new GiveCreatureModifier());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new DumpLootTablesCommand());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new KillAllCreaturesNearby());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new SetNemesisScore());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new SpawnNemesisRemote());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new RebuildZones());
		}
	}
}